extra 1.0

data/lib/extra.rb

@@ -0,0 +1,11 @@
+require 'extra/array'
+require 'extra/class'
+require 'extra/enumerable'
+require 'extra/file'
+require 'extra/module'
+require 'extra/numeric'
+require 'extra/object'
+require 'extra/objectspace'
+require 'extra/openstruct'
+require 'extra/string'
+require 'extra/symbol'

data/lib/extra/array.rb

@@ -0,0 +1,46 @@
+class Array
+	# Thanks to manveru for this fun code :)
+	# All it does is flip the first and last elements. Pretty cool, eh? :)
+	#
+	# Example: <tt>[1, 2, 3, 4].flipflop #=> [4, 2, 3, 1]</tt>
+	#
+	# Returns: Array
+	#
+	def flipflop
+		if size > 1
+			[last] + self[1...-1] + [first]
+		else
+			self
+		end
+	end
+
+	# Destructive version of Array#flipflop.
+	#
+	# Returns: Array or nil
+	#
+	def flipflop!
+		if size > 1
+			a, b = shift, pop
+			unshift(b); push(a)
+		end
+	end
+
+	# Similar to String#nothing?, except it joins all the elements first and does
+	# the same check.
+	#
+	# Example: <tt>[" ", "   ", ""].nothing? #=> true<tt>
+	#
+	# Returns: True or false.
+	#
+	def nothing?
+		join('').strip.empty?
+	end
+
+	# Check if the array contains any instances of a specific class.
+	#
+	# Example: <tt>['foo', 1, :bar].contains? Symbol #=> true</tt>
+	#
+	def contains?(klass)
+		map { |obj| obj.class }.include? klass
+	end
+end

data/lib/extra/class.rb

@@ -0,0 +1,23 @@
+class Class
+	# Get all instances of this class that exist in ObjectSpace.
+	#
+	# Example: <tt>Module.instances #=> [Marshal, ObjectSpace, GC, Math, ...]</tt>
+	#
+	# Returns: Array
+	#
+	def instances
+		objects = []; ObjectSpace.each_object(self) { |obj| objects << obj }; objects
+	end
+
+	# Check whether the class has the parent `klass'.
+	#
+	# Example: <tt>Module.has_parent?(Object) #=> true</tt>
+	#
+	# Returns: True or false
+	#
+	def ancestor?(klass)
+		ancestors[1..-1].include? klass
+	end
+
+	alias parent? ancestor?
+end

data/lib/extra/enumerable.rb

@@ -0,0 +1,55 @@
+module Enumerable
+	# Get a hash representation of an array. The number of flattened array elements
+	# has to be even in order for this to work.
+	#
+	# Example: <tt>[:foo, :bar, :baz, :qux].to_hash #=> {:foo => :bar, :baz => :qux}</tt>
+	#
+	# Returns: Hash object
+	#
+	def to_hash
+		Hash[*to_a.flatten]
+	end
+
+	# Shorthand to get the size of the enumerable object in an array state.
+	#
+	# Example: <tt>+[:a, :b, :c] #=> 3</tt>
+	#
+	# Returns: Integer size
+	#
+	def +@
+		to_a.size
+	end
+
+	# Get a random element from the array.
+	#
+	# Example: <tt>[:a, :b, :c].random #=> :b</tt>
+	#
+	# Returns: Random object(s) or nil.
+	#
+	def random(how_many = 1)
+		objects = {}
+		array   = to_a
+
+		# Let's just skip to nil if more than existent entries was requested.
+		return if array.size < how_many
+
+		# This is a longer, more efficient way than sorting the entire array.
+		how_many.times do
+			index = rand(array.size)
+			redo if objects.keys.include? index
+			objects[index] = array[index]
+		end
+
+		how_many == 1 ? objects.values[0] : objects.values
+	end
+
+	# Randomly replaces an object in the array.
+	#
+	# Example: <tt>a = [1, 2, 3]; a.random = 256; a #=> [256, 2, 3]</tt>
+	#
+	# Returns: Object
+	#
+	def random=(obj)
+		array, array[rand(array.size)] = to_a, obj
+	end
+end

data/lib/extra/file.rb

@@ -0,0 +1,14 @@
+class File
+	# Windows vs. *nix directory separator.
+	DIRECTOY_SEPARTOR = RUBY_PLATFORM =~ /win32/ ? '\\' : '/'
+
+	# Shortcut for quickly writing to a file.
+	#
+	# Example: <tt>File.write('foo.txt', 'rawr') #=> 4</tt>
+	#
+	# Returns: Bytes written
+	#
+	def self.write(filename, contents)
+		File.open(filename, 'w') { |f| f.write(contents) }
+	end
+end

data/lib/extra/module.rb

@@ -0,0 +1,24 @@
+class Module
+	# Go through each defined class in the module. Credit to apeiros for this =)
+	#
+	def each_class
+		constants.each { |constant_name|
+			constant = const_get(constant_name.intern)
+			yield constant if constant.class == Class && constant.name =~ /#{self.name}/
+		}
+	end
+
+	# List classes within a module. Thanks to apeiros for this.
+	#
+	# Example: <tt>Class.classes #=> [TrueClass, FalseClass, NilClass, Class]</tt>
+	#
+	# Returns: Array
+	#
+	def classes
+		list = []
+		each_class { |class_constant|
+			list	<< class_constant
+		}
+		return list
+	end
+end

data/lib/extra/numeric.rb

@@ -0,0 +1,82 @@
+# See the math module, as methods from Math were added in Numeric dynamically.
+#
+class Numeric
+	# Credit to manveru for this code.
+	# Checks whether a number is even.
+	#
+	# Example:
+	#
+	# <tt>  5.even? #=> false</tt>
+	#
+	# <tt>  2.even? #=> true</tt>
+	#
+	# Returns: True or false
+	#
+	def even?
+		self % 2 == 0
+	end
+
+	# Credit to manveru for this code.
+	# Checks whether a number is odd.
+	#
+	# Example:
+	#
+	# <tt>  5.odd? #=> true</tt>
+	#
+	# <tt>  2.odd? #=> false</tt>
+	#
+	# Returns: True or false
+	#
+	def odd?
+		self % 2 != 0
+	end
+
+	# Checks whether a number is a negative number.
+	# Example: <tt>-4.negative? #=> true</tt>
+	#
+	# Returns: True or false
+	#
+	def negative?
+		self < 0
+	end
+
+	# Checks whether a number is positive. Here we will consider zero as being
+	# a positive number.
+	#
+	# Example: <tt>5.positive? #=> true</tt>
+	#
+	# Returns: True or false
+	#
+	def positive?
+		self >= 0
+	end
+
+	# Add commas every 3 spots in a number.
+	#
+	# Example: <tt>(4569810.12).format #=> 4,569,810.12</tt>
+	#
+	# Returns: Commatized string
+	#
+	def format(comma = ',', decimal = '.')
+		to_s.reverse.scan(/(?:-?\d{1,3}(?:\.\d{1,3})?-?)/).map { |s| s.sub('.', decimal) }.join(comma).reverse
+	end
+
+	# Credit to apeiros for this method.
+	#
+	# Min/max method.
+	#
+	# Example: <tt>-2.crop(0..1) # => 0</tt>
+	#
+	# Returns: Numeric
+	#
+	def crop(range_or_min, max=nil)
+		range = max ? range_or_min..max : range_or_min
+		if range.include?(self)
+			self
+		elsif self < range.first
+			range.first
+		else
+			range.last
+		end
+	end
+end

data/lib/extra/object.rb

@@ -0,0 +1,88 @@
+class Object
+	# whytheluckystiff: http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+	#
+	# Gets a metaclass (a class of a class).
+	#
+	# Example: <tt>'hello'.metaclass #=> #<Class:#<String:0xb7a57998>></tt>
+	#
+	# Returns: The metaclass.
+	#
+	def metaclass
+		class << self; self; end
+	end
+
+	# whytheluckystiff: http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+	#
+	# Evaluate code on the metaclass.
+	#
+	# Example:
+	#
+	# <tt>  s = 'foo'; s.meta_eval { define_method(:longer) { self * 2 } }</tt>
+	#
+	# <tt>  s.longer #=> "foofoo"'</tt>
+	#
+	# Returns: The block's final expression.
+	#
+	def meta_eval(&block)
+		metaclass.instance_eval(&block)
+	end
+
+	# whytheluckystiff: http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+	#
+	# Define an instance method on the metaclass.
+	#
+	# Example: <tt>s = 'foo'; s.meta_def(:longer) { self * 2 }; s.longer #=> "foofoo"</tt>
+	#
+	# Returns: A Proc object of the method.
+	#
+	def meta_def(name, &block)
+		meta_eval { define_method(name, &block) }
+	end
+
+	# whytheluckystiff: http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+	#
+	# Adds a class instance method.
+	#
+	# Example:
+	#
+	# <tt>  SomeClass.class_def(:whoami) { 'I am SomeClass, silly!' }</tt>
+	#
+	# <tt>  SomeClass.whoami #=> "I am SomeClass, silly!"</tt>
+	#
+	# Returns: A Proc object of the method, or nil.
+	#
+	def class_def(name, &block)
+		class_eval { define_method(name, &block) } if kind_of? Class
+	end
+
+	# Credit to the original author. This method retrieves a deep copy of the
+	# current object.
+	#
+	# Returns: Deep copy of the same object.
+	#
+	def deepcopy
+		Marshal.load(Marshal.dump(self))
+	end
+
+	# Convert object to boolean.
+	#
+	# Example:
+	#
+	# <tt>  "foo".to_bool  #=> true</tt>
+	#
+	# <tt>  false.to_bool  #=> false</tt>
+	#
+	# <tt>  nil.to_bool    #=> nil</tt>
+	#
+	# <tt>  true.to_bool   #=> true</tt>
+	#
+	# Returns: Boolean or nil.
+	#
+	def to_bool
+		if [FalseClass, NilClass].include? self.class
+			self
+		else
+			true
+		end
+	end
+end

data/lib/extra/objectspace.rb

@@ -0,0 +1,5 @@
+module ObjectSpace
+	class << self
+		include Enumerable; alias each each_object
+	end
+end

data/lib/extra/openstruct.rb

@@ -0,0 +1,20 @@
+require 'ostruct'
+
+class OpenStruct
+	# Gets the open struct hash.
+	#
+	# Returns: Hash
+	#
+	def to_hash
+		@table
+	end
+
+	# Get the YAML representation of the struct.
+	#
+	# Returns: YAML string
+	#
+	def to_yaml(*args)
+		require 'yaml'
+		to_hash.to_yaml(*args)
+	end
+end

data/lib/extra/string.rb

@@ -0,0 +1,229 @@
+class String
+	# Generate a random string with a given length and seed.
+	#
+	# Example: <tt>String.random(4, 'abcdefg') #=> "cdeg"</tt>
+	#
+	# Returns: String
+	#
+	def self.random(length = 8, seed = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789')
+		s = ''; length.times { s << seed.shuffle[0] }; s
+	end
+
+	# Randomly shuffle a string.
+	#
+	# Example: <tt>'foobar'.shuffle #=> bofoar</tt>
+	#
+	# Returns: String
+	#
+	def shuffle
+		split(//u).sort_by { rand }.join('')
+	end
+
+	# Destructive version of String#shuffle.
+	#
+	# Returns: String or nil
+	#
+	def shuffle!
+		shuffled     =  shuffle
+		self[0..-1]  =  shuffled unless shuffled == self
+	end
+
+	# The ugly and well... unneeded Pythonic join method. Thanks to manveru for
+	# pointing out the interesting way of using array expansion with a combination
+	# of Array#flatten to support multiple arguments.
+	#
+	# Example: <tt>', '.join([1, 2, 3]) #=> "1, 2, 3"</tt>
+	#
+	# Returns: The joined string.
+	#
+	def join(*arr)
+		arr.flatten.join(self)
+	end
+
+	# Convenience method for things such as array mapping. This is identical to
+	# the version in Symbol.
+	#
+	# Example: <tt>[1, 2, 3].map(&'succ') #=> [2, 3, 4]</tt>
+	#
+	# Returns: Proc object
+	#
+	def to_proc
+		proc { |obj| obj.__send__(self) }
+	end
+
+	# For anyone who still misses PHP or Python's ord() functions... which I've
+	# learned to not need in Ruby, here it is.
+	#
+	# Example: <tt>'a'.ord #=> 97</tt>
+	#
+	# Returns: Fixnum or nil
+	#
+	def ord
+		self[0]
+	end
+
+	# Split string into an array of characters. Should be multi-byte safe...
+	#
+	# Example: <tt>'foo'.chars #=> ["f", "o", "o"]</tt>
+	#
+	# Returns: Array
+	#
+	def chars
+		split(//u)
+	end
+
+	# Capitalize words.
+	# Example: <tt>'The dog is stupid'.capitalize_words('is') #=> "The Dog is Stupid"</tt>
+	#
+	# Returns: String with words capitalized.
+	#
+	def capitalize_words(*disclude)
+		disclude = disclude.flatten
+		gsub(/\w+/u) { |word| disclude.include?(word) ? word : word.capitalize }
+	end
+
+	# My unsubmitted answer to a previous RubyQuiz question. Basically #munge will
+	# take words, scramble only the middle contents of the word while the first and
+	# last letters remain intact.
+	#
+	# Example: <tt>'You look like a terrifying goblin'.munge #=> "You look lkie a tiifyenrrg goilbn"</tt>
+	#
+	# Returns: Munged string
+	#
+	def munge
+		gsub(/\w+/u) do |word|
+			if word.size > 2
+				word[0,1] + word[1...-1].shuffle + word[-1,1]
+			else
+				word
+			end
+		end
+	end
+
+	# Destructive version of String#munge.
+	#
+	# Returns: Munged string or nil.
+	#
+	def munge!
+		munged       =  munge
+		self[0..-1]  =  munged unless munged == self
+	end
+
+	# Truncate a string to a certain length, and optionally append ending characters
+	# to it.
+	#
+	# Example: <tt>'foobarbaz'.truncate(3, '...') #=> "foo..."</tt>
+	#
+	# Returns: String
+	#
+	def truncate(length, ending = '')
+		if size > length
+			self[0...length] + ending
+		else
+			self
+		end
+	end
+
+	# Destructive version of String#truncate.
+	#
+	# Returns: String or nil
+	#
+	def truncate!(length, ending = '')
+		self[0..-1] = truncate if size > length
+	end
+
+	# Camelize string.
+	#
+	# Example: <tt>'what is my name'.camelcase #=> "whatIsMyName"</tt>
+	#
+	# Returns: String
+	#
+	def camelcase(cap_first = false)
+		if size > 1
+			camelcased       =  capitalize_words.gsub(/[^a-z]/i, '')
+			camelcased[0,1]  =  camelcased[0,1].downcase unless cap_first
+		else
+			self
+		end
+	end
+
+	# Destructive version of String#camelcase.
+	#
+	# Returns: String or nil.
+	#
+	def camelcase!(cap_first = false)
+		camelcased   =  camelcase(cap_first)
+		self[0..-1]  =  camelcased unless camelcased == self
+	end
+
+	# Removes everything except letters and spaces, replaces spaces with an
+	# underscore, and lowercases the string. The opposite of the camelcase convention.
+	#
+	# Example: <tt>"foo bar baz".underscore #=> "foo_bar_baz"</tt>
+	#
+	# Returns: String
+	#
+	def underscore
+		gsub(/[^a-z ]+/, '').gsub(/ +/, '_').downcase
+	end
+
+	# Destructive version of String#underscore.
+	#
+	# Returns: String or nil.
+	#
+	def underscore!
+		underscored = underscore
+		self[0..-1] = underscored unless underscored == self
+	end
+
+	# Convert a string to a Regexp object.
+	#
+	# Example: <tt>'foo'.to_rxp #=> /foo/</tt>
+	#
+	# Returns: Regexp object
+	#
+	def to_rxp
+		Regexp.new(self)
+	end
+
+	# Get an array of "words".
+	#
+	# Example: <tt>"hello, world!".words #=> ["hello", "world"]</tt>
+	#
+	# Returns: Array
+	#
+	def words
+		scan(/\w+/u)
+	end
+
+	# Wrap string by characters and join them by a specified separator.
+	#
+	# Example: <tt>"1234".wrap(2) #=> "12\n34"</tt>
+	#
+	# Returns: String
+	#
+	def wrap(width = 80, separator = $/)
+		scan(/.{1,#{width}}/u).join(separator)
+	end
+
+	# Destructive version of String#wrap.
+	#
+	# Returns: String or nil
+	#
+	def wrap!(width = 80, separator = $/)
+		wrapped      =  wrap(width, separator)
+		self[0..-1]  =  wrapped unless wrapped == self
+	end
+
+	# Checks if a string is nothing but whitespace or is empty.
+	#
+	# Example: <tt>" ".nothing? #=> true</tt>
+	#
+	# Returns: True or false
+	#
+	def nothing?
+		strip.empty?
+	end
+
+	alias +@ size
+end

data/lib/extra/symbol.rb

@@ -0,0 +1,13 @@
+class Symbol
+	# Credit to whomever posted this on the mailing list :)
+	#
+	# Convenience method for things such as array mapping.
+	#
+	# Example: <tt>[1, 2, 3].map(&:succ) #=> [2, 3, 4]<tt>
+	#
+	# Returns: Proc object
+	#
+	def to_proc
+		proc { |obj| obj.__send__(self) }
+	end
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: extra
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+date: 2006-05-11 00:00:00 +09:00
+summary: Adds useful methods to built-in/core Ruby classes and modules.
+require_paths: 
+- lib
+email: shugotenshi@gmail.com
+homepage: http://ruby-extra.rubyforge.org
+rubyforge_project: ruby-extra
+description: `ruby-extra' is a package full of simple/fun/useful methods that are added to the core classes and modules of Ruby. It is quite similar to Facets but is still minimal.
+autorequire: extra
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Matthew Harris
+files: 
+- lib/extra.rb
+- lib/extra/numeric.rb
+- lib/extra/array.rb
+- lib/extra/file.rb
+- lib/extra/enumerable.rb
+- lib/extra/openstruct.rb
+- lib/extra/objectspace.rb
+- lib/extra/class.rb
+- lib/extra/module.rb
+- lib/extra/symbol.rb
+- lib/extra/object.rb
+- lib/extra/string.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+