hobo_support 1.3.0.RC

data/lib/hobo_support/enumerable.rb

@@ -0,0 +1,89 @@
+module Enumerable
+
+  def map_and_find(not_found=nil)
+    each do |x|
+      val = yield(x)
+      return val if val
+    end
+    not_found
+  end
+
+  def map_with_index(res=[])
+    each_with_index {|x, i| res << yield(x, i)}
+    res
+  end
+
+  def build_hash(res={})
+    each do |x|
+      pair = block_given? ? yield(x) : x
+      res[pair.first] = pair.last if pair
+    end
+    res
+  end
+
+  def map_hash(res={})
+    each do |x|
+      v = yield x
+      res[x] = v
+    end
+    res
+  end
+
+  def rest
+    self[1..-1] || []
+  end
+
+  class MultiSender
+
+    undef_method(*(instance_methods.map{|m| m.to_s} - %w*__id__ __send__ object_id*))
+
+    def initialize(enumerable, method)
+      @enumerable = enumerable
+      @method     = method
+    end
+
+    def method_missing(name, *args, &block)
+      @enumerable.send(@method) { |x| x.send(name, *args, &block) }
+    end
+
+  end
+
+  def *()
+    MultiSender.new(self, :map)
+  end
+
+  def where
+    MultiSender.new(self, :select)
+  end
+
+  def where_not
+    MultiSender.new(self, :reject)
+  end
+
+  def drop_while
+    drop = 0
+    drop += 1 while yield(self[drop])
+    self[drop..-1]
+  end
+
+
+  def take_while
+    take = 0
+    take += 1 while yield(self[take])
+    self[0..take-1]
+  end
+
+end
+
+
+class Object
+
+  def in?(enum)
+    !enum.nil? && enum.include?(self)
+  end
+
+  def not_in?(enum)
+    enum.nil? || !enum.include?(self)
+  end
+
+end

data/lib/hobo_support/fixes/chronic.rb

@@ -0,0 +1,21 @@
+# --- Fix Chronic - can't parse '12th Jan' --- #
+begin
+  require 'chronic'
+
+  module Chronic
+
+    class << self
+      def parse_with_hobo_fix(s, *options)
+        if s =~ /^\s*\d+\s*(st|nd|rd|th)\s+[a-zA-Z]+(\s+\d+)?\s*$/
+          s = s.sub(/\s*\d+(st|nd|rd|th)/) {|s| s[0..-3]}
+        end
+
+        # Chronic can't parse '1/1/2008 1:00' or '1/1/2008 1:00 PM',
+        # so convert them to '1/1/2008 @ 1:00' and '1/1/2008 @ 1:00 PM'
+        s = s.sub(/^\s*(\d+\/\d+\/\d+)\s+(\d+:\d+.*)/, '\1 @ \2')
+        parse_without_hobo_fix(s, *options)
+      end
+      alias_method_chain :parse, :hobo_fix
+    end
+  end
+rescue LoadError; end

data/lib/hobo_support/fixes/module.rb

@@ -0,0 +1,37 @@
+class Module
+
+  # Custom alias_method_chain that won't cause inifinite recursion if
+  # called twice.
+  # Calling alias_method_chain on alias_method_chain
+  # was just way to confusing, so I copied it :-/
+  def alias_method_chain(target, feature)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+    without = "#{aliased_target}_without_#{feature}#{punctuation}"
+    unless method_defined?(without)
+      alias_method without, target
+      alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
+    end
+  end
+
+
+  # Fix delegate so it doesn't go bang if 'to' is nil
+  def delegate(*methods)
+    options = methods.pop
+    unless options.is_a?(Hash) && to = options[:to]
+      raise ArgumentError, ("Delegation needs a target. Supply an options hash with a :to key"  +
+                            "as the last argument (e.g. delegate :hello, :to => :greeter).")
+    end
+
+    methods.each do |method|
+      module_eval(<<-EOS, "(__DELEGATION__)", 1)
+        def #{method}(*args, &block)
+          (_to = #{to}) && _to.__send__(#{method.inspect}, *args, &block)
+        end
+      EOS
+    end
+  end
+
+end

data/lib/hobo_support/fixes/pp.rb

@@ -0,0 +1,13 @@
+# --- Fix pp dumps - these break sometimes without this --- #
+require 'pp'
+module PP::ObjectMixin
+
+  alias_method :orig_pretty_print, :pretty_print
+  def pretty_print(q)
+    orig_pretty_print(q)
+  rescue
+    "[#PP-ERROR#]"
+  end
+
+end
+

data/lib/hobo_support/hash.rb

@@ -0,0 +1,124 @@
+class Hash
+
+  def select_hash(&b)
+    res = {}
+    each {|k,v| res[k] = v if (b.arity == 1 ? yield(v) : yield(k, v)) }
+    res
+  end
+
+
+  def map_hash(&b)
+    res = {}
+    each {|k,v| res[k] = b.arity == 1 ? yield(v) : yield(k, v) }
+    res
+  end
+
+  def partition_hash(keys=nil)
+    yes = {}
+    no = {}
+    each do |k,v|
+      if block_given? ? yield(k,v) : keys.include?(k)
+        yes[k] = v
+      else
+        no[k] = v
+      end
+    end
+    [yes, no]
+  end
+
+  def recursive_update(hash)
+    hash.each_pair do |key, value|
+      current = self[key]
+      if current.is_a?(Hash) and value.is_a?(Hash)
+        current.recursive_update(value)
+      else
+        self[key] = value
+      end
+    end
+  end
+
+  def -(keys)
+    res = {}
+    each_pair {|k, v| res[k] = v unless k.in?(keys)}
+    res
+  end
+
+  def &(keys)
+    res = {}
+    keys.each {|k| res[k] = self[k] if has_key?(k)}
+    res
+  end
+
+  alias_method :| , :merge
+
+  def get(*args)
+    args.map {|a| self[a] }
+  end
+
+  def compact
+    res = {}
+    each { |k, v| res[k] = v unless v.nil? }
+    res
+  end
+
+  def compact!
+    keys.each { |k| delete(k) if self[k].nil? }
+  end
+
+  # Ruby 1.9.1 complains about the use of index and recommends key
+  # but Ruby 1.8 doesn't have key.  Add it.
+  alias_method(:key, :index) unless method_defined?(:key)
+
+end
+
+
+# HashWithIndifferentAccess from ActiveSupport needs different
+# versions of these
+
+if defined? HashWithIndifferentAccess
+
+  class HashWithIndifferentAccess
+
+    def -(keys)
+      res = HashWithIndifferentAccess.new
+      keys = keys.map {|k| k.is_a?(Symbol) ? k.to_s : k }
+      each_pair { |k, v| res[k] = v unless k.in?(keys) }
+      res
+    end
+
+    def &(keys)
+      res = HashWithIndifferentAccess.new
+      keys.each do |k|
+        k = k.to_s if k.is_a?(Symbol)
+        res[k] = self[k] if has_key?(k)
+      end
+      res
+    end
+
+    def partition_hash(keys=nil)
+      keys = keys._?.map {|k| k.is_a?(Symbol) ? k.to_s : k }
+      yes = HashWithIndifferentAccess.new
+      no = HashWithIndifferentAccess.new
+      each do |k,v|
+        if block_given? ? yield(k,v) : keys.include?(k)
+          yes[k] = v
+        else
+          no[k] = v
+        end
+      end
+      [yes, no]
+    end
+
+  end
+
+end
+
+if defined? ActiveSupport
+  class ActiveSupport::OrderedHash
+    alias each_pair each
+
+    def first
+      empty? ? nil : [keys.first, values.first]
+    end
+  end
+end

data/lib/hobo_support/implies.rb

@@ -0,0 +1,15 @@
+class TrueClass
+
+  def implies(x=nil)
+    block_given? ? yield : x
+  end
+
+end
+
+class FalseClass
+
+  def implies(x)
+    true
+  end
+
+end

data/lib/hobo_support/kernel.rb

@@ -0,0 +1,16 @@
+module Kernel
+
+  def dbg(*args)
+    puts "---DEBUG---"
+    args.each do |a|
+      if a.is_a?(String) && a =~ /\n/
+        puts %("""\n) + a + %(\n"""\n)
+      else
+        p a
+      end
+    end
+    puts "-----------"
+    args.first
+  end
+
+end

data/lib/hobo_support/metaid.rb

@@ -0,0 +1,28 @@
+# Thanks to _why
+
+class Object
+
+  def metaclass; class << self; self; end; end
+
+  def meta_eval(src=nil, &blk)
+    if src
+      metaclass.instance_eval(src)
+    else
+      metaclass.instance_eval &blk
+    end
+  end
+
+  def metaclass_eval(src=nil, &blk)
+    if src
+      metaclass.class_eval(src)
+    else
+      metaclass.class_eval &blk
+    end
+  end
+
+  # Adds methods to a metaclass
+  def meta_def(name, &blk)
+    meta_eval { define_method name, &blk }
+  end
+
+end

data/lib/hobo_support/methodcall.rb

@@ -0,0 +1,117 @@
+# The dot operator calls methods on objects. Power Dots are dots with extra features
+#
+#   .? calls a method if the receiver is not nil, returns nil
+#   otherwise. We have to write it ._?. in order to be valid Ruby
+#
+#   .try. calls a method only if the recipient responds to that method
+
+require 'delegate'
+require 'singleton'
+require 'blankslate'
+
+module HoboSupport
+  def self.hobo_try(this, *args, &block)
+    if args.length==0
+      # Hobo style try
+      CallIfAvailable.new(this)
+    else
+      # activesupport 2.3 style try
+      this.send(*args, &block)
+    end
+  end
+end
+
+class Object
+
+  def _?()
+    self
+  end
+
+  def try(*args, &block)
+    HoboSupport.hobo_try(self, *args, &block)
+  end
+
+end
+
+
+class NilClass
+  def _?()
+    SafeNil.instance
+  end
+
+
+  def try(*args)
+    if args.length==0
+      # Hobo style try
+      CallIfAvailable.new(self)
+    else
+      # activesupport 2.3 style try
+      nil
+    end
+  end
+
+end
+
+
+class SafeNil
+  include Singleton
+
+  begin
+    old_verbose, $VERBOSE = $VERBOSE, nil   # just like Rails silence_warnings: suppress "warning: undefining `object_id' may cause serious problem"
+    instance_methods.each { |m| undef_method m unless m[0,2] == '__' }
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  def method_missing(method, *args, &b)
+    return nil
+  end
+end
+
+
+alias DelegateClass_without_safe_nil DelegateClass
+def DelegateClass(klass)
+  c = DelegateClass_without_safe_nil(klass)
+  c.class_eval do
+    def _?
+      self
+    end
+  end
+  c
+end
+
+
+class CallIfAvailable < BlankSlate
+
+  def initialize(target)
+    @target = target
+  end
+
+  def method_missing(name, *args, &b)
+    @target.send(name, *args, &b) if @target.respond_to?(name)
+  end
+
+end
+
+module ActiveRecord
+  module Associations
+    class AssociationProxy
+
+      # we need to make sure we don't trigger AssociationCollections' method_missing
+      def try(*args, &block)
+        HoboSupport.hobo_try(self, *args, &block)
+      end
+    end
+  end
+
+  module NamedScope
+    class Scope
+      # we need to make sure we don't trigger AssociationCollections' method_missing
+      def try(*args, &block)
+        HoboSupport.hobo_try(self, *args, &block)
+      end
+    end
+  end
+
+end
+