hobo_support 1.3.0.RC

data/lib/hobo_support/methodphitamine.rb

@@ -0,0 +1,33 @@
+# From: http://jicksta.com/articles/2007/08/04/the-methodphitamine
+
+require 'blankslate'
+
+module Kernel
+
+  def it() It.new end
+  alias its it
+
+end
+
+class It
+
+  instance_methods.reject { |m| m =~ /^__/ || m.to_s == 'object_id' }.each { |m| undef_method m }
+
+  def initialize
+    @methods = []
+  end
+
+  def method_missing(*args, &block)
+    @methods << [args, block] unless args == [:respond_to?, :to_proc]
+    self
+  end
+
+  def to_proc
+    lambda do |obj|
+      @methods.inject(obj) do |current,(args,block)|
+        current.send(*args, &block)
+      end
+    end
+  end
+
+end

data/lib/hobo_support/module.rb

@@ -0,0 +1,102 @@
+class Module
+
+  private
+
+  # In a module definition you can include a call to
+  # included_in_class_callbacks(base) at the end of the
+  # self.included(base) callback. Any modules that your module includes
+  # will receive an included_in_class callback when your module is
+  # included in a class. Useful if the sub-module wants to do something
+  # like alias_method_chain on the class.
+  def included_in_class_callbacks(base)
+    if base.is_a?(Class)
+      included_modules.each { |m| m.try.included_in_class(base) }
+    end
+  end
+
+  # Creates a class attribute reader that will delegate to the superclass
+  # if not defined on self. Default values can be a Proc object that takes the class as a parameter.
+  def inheriting_cattr_reader(*names)
+    names_with_defaults = (names.pop if names.last.is_a?(Hash)) || {}
+
+    (names + names_with_defaults.keys).each do |name|
+      ivar_name = "@#{name}"
+      block = names_with_defaults[name]
+      self.send(self.class == Module ? :define_method : :meta_def, name) do
+        if instance_variable_defined? ivar_name
+          instance_variable_get(ivar_name)
+        else
+          superclass.respond_to?(name) && superclass.send(name) ||
+          block && begin
+            result = block.is_a?(Proc) ? block.call(self) : block
+            instance_variable_set(ivar_name, result) if result
+          end
+        end
+      end
+    end
+  end
+
+  def inheriting_cattr_accessor(*names)
+    names_with_defaults = (names.pop if names.last.is_a?(Hash)) || {}
+
+    names_with_defaults.keys.each do |name|
+      attr_writer name
+      inheriting_cattr_reader names_with_defaults.slice(name)
+    end
+    names.each do |name|
+      attr_writer name
+      inheriting_cattr_reader name
+    end
+  end
+
+
+  # creates a #foo= and #foo? pair, with optional default values, e.g.
+  # bool_attr_accessor :happy => true
+  def bool_attr_accessor(*args)
+    options = (args.pop if args.last.is_a?(Hash)) || {}
+
+    (args + options.keys).each {|n| class_eval "def #{n}=(x); @#{n} = x; end" }
+
+    args.each {|n| class_eval "def #{n}?; @#{n}; end" }
+
+    options.keys.each do |n|
+      class_eval %(def #{n}?
+                     if !defined? @#{n}
+                       @#{n} = #{options[n] ? 'true' : 'false'}
+                     else
+                       @#{n}
+                     end
+                   end)
+      set_field_type(n => TrueClass) if respond_to?(:set_field_type)
+    end
+  end
+
+  def alias_class_method_chain(method, feature)
+    meta_eval do
+      alias_method_chain method, feature
+    end
+  end
+
+end
+
+
+# classy_module lets you extract code from classes into modules, but
+# still write it the same way
+module Kernel
+
+  def classy_module(mod=Module.new, &b)
+    mod.meta_def :included do |base|
+      base.class_eval &b
+    end
+    mod
+  end
+
+end
+
+class Object
+
+  def is_one_of?(*args)
+    args.any? {|a| is_a?(a) }
+  end
+
+end

data/lib/hobo_support/string.rb

@@ -0,0 +1,34 @@
+class String
+
+  def remove(string_or_rx)
+    sub(string_or_rx, '')
+  end
+
+  def remove!(string_or_rx)
+    sub!(string_or_rx, '')
+  end
+
+  def remove_all(string_or_rx)
+    gsub(string_or_rx, '')
+  end
+
+  def remove_all!(string_or_rx)
+    gsub!(string_or_rx, '')
+  end
+
+  # Return the constant that this string refers to, or nil if ActiveSupport cannot load such a
+  # constant. This is much safer than `rescue NameError`, as that will mask genuine NameErrors
+  # that have been made in the code being loaded (#safe_constantize will not)
+  def safe_constantize
+    Object.class_eval self
+  rescue NameError => e
+    if e.missing_name != self
+      # oops - some other name error
+      raise
+    else
+      nil
+    end
+  end
+
+
+end

data/lib/hobo_support/xss.rb

@@ -0,0 +1,11 @@
+require 'active_support/core_ext/string/output_safety'
+class Array
+  # it always returns an html_safe? string preserving the html_safe?
+  # items and separator, excaping the rest
+  def safe_join(sep=$,)
+    map {|i| ERB::Util.html_escape(i)}.join(ERB::Util.html_escape(sep)).html_safe
+  end
+end
+
+
+

data/test/hobosupport.rdoctest

@@ -0,0 +1,75 @@
+# HoboSupport
+
+HoboSupport is a mixed bag of core ruby extensions that have been extracted from the [Hobo][] project
+
+[Hobo]: http://hobocentral.net
+
+    doctest_require: '../lib/hobo_support'
+{.hidden}
+
+
+## Contents
+
+ * [Enumerable](/manual/hobo_support/enumerable)
+ * [Hash](/manual/hobo_support/hash)
+ * [Implies](/manual/hobo_support/implies)
+ * [Metaid](/manual/hobo_support/metaid)
+ * [Methodphitamine](/manual/hobo_support/methodphitamine)
+ * [Module](/manual/hobo_support/module)
+
+## Object extensions
+
+### `Object#is_one_of?`
+
+Like `is_a?` but multiple types to be checked in one go
+
+    >> "foo".is_one_of?(String, Symbol)
+    => true
+    >> :foo.is_one_of?(String, Symbol)
+    => true
+    >> 1.is_one_of?(String, Symbol)
+    => false
+
+## Method call extensions
+
+We have the "." operator to call methods on objects. These extensions introduce two "special dots".
+
+### `Object#_?`
+
+"`._?.`" only calls the method if the receiver is not `nil`.  Otherwise it returns nil.  So `x._?.method(*args)` is equivalent to `(nil == x ? nil : x.method(*args))`.
+
+    >> "foo"._?.length
+    => 3
+    >> nil._?.length
+    => nil
+
+When the receiver is nil, any method with any arguments will return nil.  You can use Ruby's || idiom to provide a different value when nil.
+
+    >> expires = nil
+    >> expires._?.to_s( :default ) || "never"
+    => "never"
+
+Note that `_?` should *always* be followed by a method call.  It is not intended to store the intermediate result.  Don't do this!
+
+intermediate = nil._?
+
+### `Object#try`
+
+"`.try`" only calls the method if the receiver responds to that method.  Otherwise it returns nil.  So `x.try.method(*args)` is equivalent to `(x.respond_to?(:method) ? x.method(*args) : nil)`.
+
+    >> "foo".try.reverse
+    => "oof"
+    >> :foo.try.reverse
+    => nil
+
+### What's the difference?
+
+Use `_?` when you want to call a method but you know the receiver may be nil.
+Use `try` when you want to call a method but you know the receiver may not respond to it.  For instance, you
+may use `try` to call a Rails 2.3 function that doesn't exist on Rails
+2.2.  Note that nil responds to some functions that may surprise you.
+
+    >> nil.try.to_i
+    => 0
+    >> nil._?.to_i
+    => nil

data/test/hobosupport/chronic.rdoctest

@@ -0,0 +1,18 @@
+# HoboSupport - Chronic extensions
+
+    doctest_require: '../../lib/hobo_support'
+{.hidden}
+
+## `Chronic.parse`
+
+Chronic.parse can't parse 'M/D/Y H:S', so convert it to 'M/D/Y @ H:S'.
+
+    >> Chronic.parse('1/1/2008 1:00') == Chronic.parse('1/1/2008 @ 1:00')
+
+    => true
+
+Chronic.parse takes additional options (see Chronic.parse).
+
+    >> Chronic.parse('today', :guess => false).instance_of? Chronic::Span
+
+    => true

data/test/hobosupport/enumerable.rdoctest

@@ -0,0 +1,130 @@
+# HoboSupport - Eumerable extensions
+
+    doctest_require: '../../lib/hobo_support'
+
+## `Enumerable#map_and_find`
+
+* `enum.map_and_find(not_found) { |element| block}`
+
+Iterates through an enumerable passing each element in turn to the block. Returns the first true value returned by the block, or `not_found` if the block never returns a true value.
+
+E.g. The length of the first word that starts with a capital letter
+
+    >> %w(my name is Fred).map_and_find { |s| s.length if s =~ /^[A-Z]/ }
+    => 4
+
+## `Enumerable#map_with_index`
+
+* `enum.map_with_index { |element, index| block }`
+
+Just like #map but the block gets the element and the index.
+
+    >> %w(some short words).map_with_index { |s, i| s * i }
+    => ["", "short", "wordswords"]
+
+## `Enumerable#build_hash`
+
+* `enum.build_hash { |element| block }`
+
+The block is passed each element in turn and should return a key/value pair. If the block returns nil, nothing is added to the hash.
+
+    >> %w(some short words).build_hash { |s| [s, s.length] unless s == "short" }
+    => {"some"=>4, "words"=>5}
+
+
+## `Enumerable#map_hash`
+
+* `enum.map_hash { |element| block }`
+
+Each element is passed to the block. Returns a hash where the keys are the elements from the enumerable, and the values are those returned by the block for the given key.
+
+    >> %w(some short words).map_hash { |s| s.length }
+    => {"some"=>4, "short"=>5, "words"=>5}
+
+## `Enumerable#rest`
+
+Shorthand for `enum[1..-1]`
+
+    >> %w(some short words).rest
+    => ["short", "words"]
+
+
+## `Enumerable#*`
+
+Shorthand for `map` when you need to map a single method call on the elements.
+
+    >> %w(some short words).*.length
+    => [4, 5, 5]
+
+## `Enumerable#where`
+
+Shorthand for `select` when you need to select on a single method call.
+
+    >> %w(some short words).where.include?("r")
+    => ["short", "words"]
+
+## `Enumerable#where_not`
+
+Shorthand for `reject` when you need to reject on a single method call.
+
+    >> %w(some short words).where_not.include?("r")
+    => ["some"]
+
+## `Enumerable#drop_while`
+
+* `enum.drop_while { |element| block }`
+
+Passes each element in turn to the block until the block returns false. Returns the remaining elements in a new array.
+
+    >> %w(this is a nice example).drop_while { |s| s.length > 1 }
+    => ["a", "nice", "example"]
+
+There is also a destructive version for arrays
+
+    >> a = %w(this is a nice example)
+    >> a.drop_while! { |s| s.length > 1 }
+    >> a
+    => ["a", "nice", "example"]
+
+
+## `Enumerable#take_while`
+
+* `enum.take_while { |element| block }`
+
+Passes each element in turn to the block until the block returns false. Returns a new with the elements for which the block returned true
+
+    >> %w(this is a nice example).take_while { |s| s.length > 1 }
+    => ["this", "is"]
+
+
+## `Object#in?`
+
+* `obj.in?(enum)`
+
+Shorthand for `enum.include?(obj)`
+
+    >> 3.in?(0..10)
+    => true
+    >> 300.in?(0..10)
+    => false
+
+`in?` treats nil as an empty enumeration:
+
+    >> 3.in?(nil)
+    => false
+
+## `Object#not_in?`
+
+* `obj.not_in?(enum)`
+
+Negation of `in?`
+
+    >> 3.not_in?(0..10)
+    => false
+    >> 300.not_in?(0..10)
+    => true
+
+`not_in?` treats nil as an empty enumeration:
+
+    >> 3.not_in?(nil)
+    => true

data/test/hobosupport/hash.rdoctest

@@ -0,0 +1,123 @@
+# HoboSupport - Hash extensions
+
+    doctest_require: '../../lib/hobo_support'
+{.hidden}
+
+## `Hash#select_hash`
+
+* `hash.select_hash { |key, value| block } => hash`
+* `hash.select_hash { |value| block } => hash`
+
+This is the Hash version of `Enumerable#select`. i.e. a way to create a new hash with only some of the items still present. The block is passed each key value pair. The new hash only contains items for which the block returned true.
+
+    >> {1=>2, 3=>4, 6=>5}.select_hash { |key, value| key < value }
+    => {1=>2, 3=>4}
+
+You can also give a block that takes one argument, in which case the block is given the value only
+
+    >> {1=>2, 3=>4, 6=>5}.select_hash { |value| value != 2 }
+    => {3=>4, 6=>5}
+
+
+## `Hash#map_hash`
+
+* `hash.map_hash { |key, value| block } => hash`
+* `hash.map_hash { |value| block } => hash`
+
+Applies a function to each *value* in a Hash, resulting in a new hash with the same keys but new values. The block is passed each key, value pair and should return the new value
+
+    >> {1=>2, 3=>4, 6=>5}.map_hash { |key, value| key < value }
+    => {1=>true, 3=>true, 6=>false}
+
+You can also give a block which takes one argument, in which case only the value is passed in
+
+    >> {1=>2, 3=>4, 6=>5}.map_hash { |value| value * 100 }
+    => {1=>200, 3=>400, 6=>500 }
+
+
+## `Hash#partition_hash`
+
+* `hash.partition_hash(keys) => [hash1, hash2]`
+* `hash.partition_hash { |key, value| block } => hash`
+
+Returns an array of two hashes, the first with all the key/value pairs where the key was in passed Enumerable, the second with the remaining key/value pairs
+
+    >> {1=>2, 3=>4, 6=>5}.partition_hash([1, 3])
+    => [{1=>2, 3=>4}, {6=>5}]
+
+When passed a block, each pair is passed to the block in turn. The result is two hashes, the first containing those pairs for which the block returned true, the second with the remaining pairs
+
+    >> {1=>2, 3=>4, 6=>5}.partition_hash { |key, value| key < value }
+    => [{1=>2, 3=>4}, {6=>5}]
+
+## `Hash.recursive_update`
+
+* `hash.recursive_update(hash2)`
+
+Like `#update` but where a sub-hash would overwrite another sub-hash, they are instead also merged, recursively
+
+    >> h = { :a => 1, :b => { :x => 10 } }
+    >> h.recursive_update({ :c => 3, :b => { :y => 20 } })
+    >> h
+    => { :a => 1, :b => { :x => 10, :y => 20}, :c => 3 }
+
+
+## `Hash#-`
+
+* `hash - array => hash`
+
+Returns a new hash, the left-hand-side hash with all pairs removed where the key is present in the right-hand-side array.
+
+    >> {1=>2, 3=>4, 6=>5} - [1, 3]
+    => {6 => 5}
+
+## `Hash#&`
+
+* `hash & array => array`
+
+Returns a new array, the left hand side hash restricted to pairs where the key is present in the right-hand-side array
+
+    >> {1=>2, 3=>4, 6=>5} & [1, 3]
+    => {1=>2, 3=>4}
+
+## `Hash#|`
+
+* `hash | hash => hash`
+
+An alias for merge
+
+    >> {1 => 2} | {1 => 3, 2 => 4}
+    => {1 => 3, 2 => 4}
+
+
+## `Hash#get`
+
+* `hash.get(*args) => hash`
+
+Returns an array of values for the given keys. Useful for extracting a few options into local variables.
+
+    >> {1=>2, 3=>4, 6=>5}.get(1, 3)
+    => [2, 4]
+
+## `Hash#compact`
+
+* `hash.compact => hash`
+
+Returns a hash with the same items as the receiver except those where the value is nil
+
+    >> {1=>'a', 2=>nil, 3=>'b'}.compact
+    => {1=>'a', 3=>'b'}
+
+## `Hash#compact`
+
+* `hash.compact!`
+
+Removes every pair from the hash where the value is nil
+
+    >> h = {1=>'a', 2=>nil, 3=>'b'}
+    >> h.compact!
+    >> h
+    => {1=>'a', 3=>'b'}
+
+
+