mack-facets 0.6.0

data/README

@@ -0,0 +1,3 @@
+README
+========================================================================
+mack-facets was developed by: markbates

data/lib/english_extensions/inflect.rb

@@ -0,0 +1,50 @@
+module English # :nodoc:
+
+  # = English Nouns Number Inflection.
+  #
+  # This module provides english singular <-> plural noun inflections.
+  module Inflect # :nodoc:
+
+    class << self
+
+      # Convert an English word from plurel to singular.
+      #
+      #   "boys".singular      #=> boy
+      #   "tomatoes".singular  #=> tomato
+      #
+      def singular(word)
+        if result = singular_of[word]
+          return result.dup
+        end
+        result = word.dup
+        singularization_rules.each do |(match, replacement)|
+          break if result.gsub!(match, replacement)
+        end
+        # Mack: cache the result of the translation:
+        singular_of[word] = result unless word == result
+        return result
+      end
+      
+      # Convert an English word from singular to plurel.
+      #
+      #   "boy".plural     #=> boys
+      #   "tomato".plural  #=> tomatoes
+      #
+      def plural(word)
+        if result = plural_of[word]
+          return result.dup
+        end
+        #return self.dup if /s$/ =~ self # ???
+        result = word.dup
+        pluralization_rules.each do |(match, replacement)|
+          break if result.gsub!(match, replacement)
+        end
+        # Mack: cache the result of the translation:
+        plural_of[word] = result unless word == result
+        return result
+      end
+
+    end
+
+  end
+end

data/lib/english_extensions/numerals.rb

@@ -0,0 +1,12 @@
+class Integer #:nodoc:
+
+  #
+  #   10.english #=> 'ten'
+
+  include English::Numerals
+
+  def english
+    self.name(self)
+  end
+
+end

data/lib/extensions/array.rb

@@ -0,0 +1,90 @@
+class Array
+  
+  # This method is useful when you have a method that looks like this:
+  # def foo(*args)
+  #   do something
+  # end
+  # The problem is when you use the * like that everything that comes in is
+  # an array. Here are a few problems with this:
+  # foo([1,2,3])
+  # When you pass an array into this type of method you get the following nested array:
+  # [[1,2,3]]
+  # The parse_splat_args method, if called, would do this:
+  # args.parse_splat_args # => [1,2,3]
+  # Now say you called this method like such:
+  # foo(1)
+  # args would be [1]
+  # args.parse_splat_args # => 1
+  # Finally
+  # foo
+  # args.parse_splat_args # => nil
+  def parse_splat_args
+    unless self.empty?
+      args = self#.flatten
+      case args.size
+      when 1
+        return args.first # if there was only one arg passed, return just that, without the array
+      when 0
+        return nil # if no args were passed return nil
+      else
+        return args # else return the array back, cause chances are that's what they passed you!
+      end
+    end
+  end
+  
+  # This will return a new instance of the array sorted randomly.
+  def randomize(&block)
+    if block_given?
+      self.sort {|x,y| yield x, y}
+    else
+      self.sort_by { rand }
+    end
+  end
+  
+  # This calls the randomize method, but will permantly replace the existing array.
+  def randomize!(&block)
+    if block_given?
+      self.replace(self.randomize(&block))
+    else
+      self.replace(self.randomize)
+    end
+  end
+  
+  # This will pick a random value from the array
+  def pick_random
+    self[rand(self.length)]
+  end
+  
+  # This allows you to easily recurse of the array randomly.
+  def random_each
+    self.randomize.each {|x| yield x}
+  end
+  
+  def subset?(other)
+    self.each do |x|
+      return false if !(other.include? x)
+    end
+    true
+  end
+  
+  def superset?(other)
+    other.subset?(self)
+  end
+  
+  # This will give you a count, as a Hash, of all the values in the Array.
+  # %w{spam spam eggs ham eggs spam}.count # => {"eggs" => 2, "ham" => 1, "spam" => 3}
+  def count
+    k = Hash.new(0)
+    self.each{|x| k[x] += 1}
+    k
+  end
+  
+  # This will invert the index and the values and return a Hash of the results.
+  # %w{red yellow orange}.invert # => {"red" => 0, "orange" => 2, "yellow" => 1}
+  def invert
+    h = {}
+    self.each_with_index{|x,i| h[x] = i}
+    h
+  end
+  
+end

data/lib/extensions/class.rb

@@ -0,0 +1,38 @@
+class Class
+  
+  # Returns a new Object instance of the class name specified.
+  # 
+  # Examples:
+  #   Class.new_instance_of("Orange") => #<Orange:0x376c0c>
+  #   Class.new_instance_of("Animals::Dog") => #<Animals::Dog:0x376a2c>
+  def self.new_instance_of(klass_name)
+    klass_name.constantize.new
+  end
+  
+  # This will through the ancestor tree of object and tell you if
+  # that object is of the specified type.
+  def class_is_a?(klass_name)
+    self.ancestors.each do |an|
+      if an == klass_name
+        return true
+      end
+    end
+    return false
+  end
+  
+  # Returns an array of the classes parent classes.
+  # 
+  # Examples:
+  #   Orange.parents # => [Citrus, Fruit, Object]
+  #   Citrus.parents # => [Fruit, Object]
+  #   Fruit.parents # => [Object]
+  def parents
+    ans = [self.superclass]
+    until ans.last.superclass.nil?
+      ans << ans.last.superclass
+    end
+    ans
+  end
+  
+end
+  

data/lib/extensions/hash.rb

@@ -0,0 +1,49 @@
+require 'uri'
+class Hash
+  
+  def join(pair_string, join_string)
+    output = []
+    sorted = self.sort {|a,b| a[0].to_s <=> b[0].to_s}
+    sorted.each do |ar|
+      output << sprintf(pair_string, ar[0], ar[1])
+    end
+    output.join(join_string)
+  end
+  
+  # Deletes the key(s) passed in from the hash.
+  def -(ars)
+    [ars].flatten.each {|a| self.delete(a)}
+    self
+  end
+  
+  # Converts a hash to query string parameters. 
+  # An optional boolean escapes the values if true, which is the default.
+  def to_params(escape = true)
+    params = ''
+    stack = []
+    
+    each do |k, v|
+      if v.is_a?(Hash)
+        stack << [k,v]
+      else
+        v = v.to_s.uri_escape if escape
+        params << "#{k}=#{v}&"
+      end
+    end
+    
+    stack.each do |parent, hash|
+      hash.each do |k, v|
+        if v.is_a?(Hash)
+          stack << ["#{parent}[#{k}]", v]
+        else
+          v = v.to_s.uri_escape if escape
+          params << "#{parent}[#{k}]=#{v}&"
+        end
+      end
+    end
+    
+    params.chop! # trailing &
+    params.split("&").sort.join("&")
+  end
+  
+end

data/lib/extensions/kernel.rb

@@ -0,0 +1,34 @@
+require 'pp'
+require 'stringio'
+
+module Kernel
+  
+  def pp_to_s(object)
+    pp_out = StringIO.new
+    PP.pp(object,pp_out)
+    return pp_out.string
+  end
+  
+  def retryable(options = {}, &block)
+    opts = { :tries => 1, :on => Exception }.merge(options)
+
+    retries = opts[:tries]
+    retry_exceptions = [opts[:on]].flatten
+    
+    x = %{
+      begin
+        return yield
+      rescue #{retry_exceptions.join(", ")} => e
+        retries -= 1
+        if retries > 0
+          retry
+        else
+          raise e
+        end
+      end        
+    }
+
+    eval(x, &block)
+  end
+  
+end

data/lib/extensions/math.rb

@@ -0,0 +1,15 @@
+module Math
+
+  def self.log2(x)
+     self.log(x)/self.log(2.0)
+  end
+
+  def self.min(a, b)
+     a < b ? a : b
+  end
+
+  def self.max(a, b)
+     a > b ? a : b
+  end
+
+end

data/lib/extensions/module.rb

@@ -0,0 +1,29 @@
+class Module
+  
+  # Bulk converts the security level of methods in this Module from one level to another.
+  def convert_security_of_methods(old_level = :public, new_level = :protected)
+    eval("#{old_level}_instance_methods").each{ |meth| self.send(new_level, meth) }
+    self
+  end
+  
+  # Includes this module into a Class, and changes all public methods to protected.
+  # 
+  # Examples:
+  #   module MyCoolUtils
+  #     def some_meth
+  #       "hi"
+  #     end
+  #     self.include_safely_into(FooController)
+  #   end
+  # or:
+  #   MyCoolUtils.include_safely_into(FooController, SomeOtherClass)
+  def include_safely_into(*args)
+    [args].flatten.each do |a|
+      if a.is_a?(String) || a.is_a?(Symbol)
+        a = a.to_s.constantize
+      end
+      a.send(:include, self.convert_security_of_methods)
+    end
+  end
+  
+end

data/lib/extensions/object.rb

@@ -0,0 +1,164 @@
+class Object
+  
+  # Includes a module into the current Class, and changes all the module's public methods to protected.
+  # 
+  # Example:
+  #   class FooController
+  #     safely_include_module(MyCoolUtils, MyOtherModule)
+  #   end
+  def safely_include_module(*modules)
+    [modules].flatten.each do |mod|
+      mod.include_safely_into(self)
+    end
+  end
+  
+  # Prints out the methods associated with this object in alphabetical order.
+  def print_methods
+    m = "----- #{self} (methods) -----\n"
+    m << methods.sort.join("\n")
+    puts m
+    m
+  end
+
+  # An elegant way to refactor out common options
+  # 
+  #   with_options :order => 'created_at', :class_name => 'Comment' do |post|
+  #     post.has_many :comments, :conditions => ['approved = ?', true], :dependent => :delete_all
+  #     post.has_many :unapproved_comments, :conditions => ['approved = ?', false]
+  #     post.has_many :all_comments
+  #   end
+  #
+  # Can also be used with an explicit receiver:
+  #
+  #   map.with_options :controller => "people" do |people|
+  #     people.connect "/people",     :action => "index"
+  #     people.connect "/people/:id", :action => "show"
+  #   end
+  #  
+  def with_options(options)
+    yield Mack::Utils::OptionMerger.new(self, options)
+  end
+  
+  # See Class parents for more information.
+  def class_parents
+    self.class.parents
+  end
+  
+  # This method gets called when a parameter is passed into a named route.
+  # This can be overridden in an Object to provlde custom handling of parameters.
+  def to_param
+    self.to_s
+  end
+  
+  # Uses <code>define_method</code> to create an empty for the method parameter defined.
+  # That method will then raise MethodNotImplemented. This is useful for creating interfaces
+  # and you want to stub out methods that others need to implement.
+  def self.needs_method(meth)
+    define_method(meth) do
+      raise NoMethodError.new("The interface you are using requires you define the following method '#{meth}'")
+    end
+  end
+  
+  # This prints out running time for the block provided. This is great for things
+  # like Rake tasks, etc... where you would like to know how long it, or a section of
+  # it took to run.
+  def running_time(message = "", logger = nil)
+    s_time = Time.now
+    s = "---Starting at #{s_time}---"
+    puts s
+    logger.info s unless logger.nil?
+    yield if block_given?
+    e_time = Time.now
+    e = "---Ending at #{e_time}---"
+    puts e
+    logger.info e unless logger.nil?
+    secs = e_time - s_time
+    if secs < 60
+      x = "Running time #{secs} seconds."
+    else
+      x = "Running time roughly #{secs/60} minutes [#{secs} seconds]"
+    end
+    x += " [MESSAGE]: #{message}" unless message.blank?
+    puts x
+    logger.info x unless logger.nil?
+  end
+  
+  # This method will call send to all the methods defined on the previous method.
+  # 
+  # Example:
+  #   Fruit.send_with_chain([:new, :get_citrus, :get_orange, :class]) # => Orange
+  # 
+  # This would be the equivalent:
+  #   Fruit.new.get_citrus.get_orange.class
+  def send_with_chain(methods, *args)
+    obj = self
+    [methods].flatten.each {|m| obj = obj.send(m, *args)}
+    obj
+  end
+  
+  # ivar_cache allows you to cache the results of the block into an instance variable in a class,
+  # and then will serve up that instance variable the next time you call that method again.
+  # 
+  # old way:
+  #   def show_page_link
+  #     unless @show_page_link # check if instance variable exists
+  #       # if the instance variable doesn't exist let's do some work and assign it to the instance variable.
+  #       @show_page_link = link_to("show", some_url(:id => self.id, :foo => bar, etc... => etc))
+  #     end
+  #     @show_page_link # now return the instance variable
+  #   end
+  # 
+  # new way:
+  #   def show_page_link
+  #     ivar_cache do
+  #       link_to("show", some_url(:id => self.id, :foo => bar, etc... => etc))
+  #     end
+  #   end
+  # 
+  # this does everything the old way did, but it is much cleaner, and a lot less code!
+  # in case you're wondering it caches the result, by default, to an instance variable named after the method,
+  # so in our above example the instance variable would be name, <code>@show_page_link</code>. this can be overridden like such:
+  # 
+  #   def show_page_link
+  #     ivar_cache("foo_var") do
+  #       link_to("show", some_url(:id => self.id, :foo => bar, etc... => etc))
+  #     end
+  #   end
+  # 
+  # now it will cache it to <code>@foo_var</code>
+  def ivar_cache(var_name = nil, &block)
+    if var_name.nil?
+      call = caller[0]
+      var_name = call[(call.index('`')+1)...call.index("'")]
+    end
+    var = instance_variable_get("@#{var_name}")
+    unless var
+      return instance_variable_set("@#{var_name}", yield) if block_given?
+    end
+    instance_variable_get("@#{var_name}")
+  end
+  
+  def ivar_cache_clear(var_name = nil, &block)
+    if var_name.nil?
+      call = caller[0]
+      var_name = call[(call.index('`')+1)...call.index("'")]
+    end
+    remove_instance_variable("@#{var_name}") #rescue
+    yield if block_given?
+  end
+  
+  # Returns the namespaces for a particular object.
+  # 
+  # Examples:
+  #   Animals::Dog::Poodle.new.namespaces # => ["Animals", "Dog"]
+  def namespaces
+    ivar_cache("object_namespaces") do
+      nss = []
+      full_name = self.class.name.to_s
+      nss = full_name.split("::")
+      nss.pop
+      nss
+    end
+  end
+  
+end

data/lib/extensions/string.rb

@@ -0,0 +1,218 @@
+class String
+  include Style
+  
+  def methodize
+    x = self
+    
+    # if we get down to a nil or an empty string raise an exception! 
+    raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
+    
+    # get rid of the big stuff in the front/back
+    x.strip!
+    
+    # if we get down to a nil or an empty string raise an exception! 
+    raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
+    
+    x = x.underscore
+    
+    # get rid of spaces and make the _
+    x.gsub!(' ', '_')
+    # get rid of everything that isn't 'safe' a-z, 0-9, ?, !, =, _
+    x.gsub!(/([^ a-zA-Z0-9\_\?\!\=]+)/n, '_')
+    
+    # if we get down to a nil or an empty string raise an exception! 
+    raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
+    
+    # condense multiple 'safe' non a-z chars to just one.
+    # ie. ___ becomes _ !!!! becomes ! etc...
+    [' ', '_', '?', '!', "="].each do |c|
+      x.squeeze!(c)
+    end
+    
+    # if we get down to a nil or an empty string raise an exception! 
+    raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
+    
+    #down case the whole thing
+    x.downcase!
+    
+    # get rid of any characters at the beginning that aren't a-z
+    while !x.match(/^[a-z]/)
+      x.slice!(0)
+      
+      # if we get down to a nil or an empty string raise an exception! 
+      raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
+    end
+    
+    # let's trim this bad boy down a bit now that we've cleaned it up, somewhat.
+    # we should do this before cleaning up the end character, because it's possible to end up with a 
+    # bad char at the end if you trim too late.
+    x = x[0..100] if x.length > 100
+    
+    # get rid of any characters at the end that aren't safe
+    while !x.match(/[a-z0-9\?\!\=]$/)
+      x.slice!(x.length - 1)
+      # if we get down to a nil or an empty string raise an exception! 
+      raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
+    end
+    
+    # if we get down to a nil or an empty string raise an exception! 
+    raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
+    
+    # let's get rid of characters that don't belong in the 'middle' of the method.
+    orig_middle = x[1..(x.length - 2)]
+    n_middle = orig_middle.dup
+    
+    ['?', '!', "="].each do |c|
+      n_middle.gsub!(c, "_")
+    end
+    
+    # the previous gsub can leave us with multiple underscores that need cleaning up.
+    n_middle.squeeze!("_")
+    
+    x.gsub!(orig_middle, n_middle)
+    x.gsub!("_=", "=")
+    x
+  end
+  
+  # Returns a constant of the string.
+  # 
+  # Examples:
+  #   "User".constantize # => User
+  #   "HomeController".constantize # => HomeController
+  #   "Mack::Configuration" # => Mack::Configuration
+  def constantize
+    Module.instance_eval("::#{self}")
+  end
+  
+  def hexdigest
+    Digest::SHA1.hexdigest(self)
+  end                                    
+  
+  def hexdigest!
+    self.replace(self.hexdigest)
+  end
+  
+  def self.randomize(length = 10)
+    chars = ("A".."H").to_a + ("J".."N").to_a + ("P".."T").to_a + ("W".."Z").to_a + ("3".."9").to_a
+    newpass = ""
+    1.upto(length) { |i| newpass << chars[rand(chars.size-1)] }
+    return newpass.upcase
+  end
+  
+  # Performs URI escaping so that you can construct proper
+  # query strings faster.  Use this rather than the cgi.rb
+  # version since it's faster.  (Stolen from Camping).
+  def uri_escape
+    self.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+      '%'+$1.unpack('H2'*$1.size).join('%').upcase
+    }.tr(' ', '+')
+  end
+
+  # Unescapes a URI escaped string. (Stolen from Camping).
+  def uri_unescape
+    self.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
+      [$1.delete('%')].pack('H*')
+    }
+  end
+  
+  def truncate(length = 30, truncate_string = "...")
+    if self.nil? then return end
+    l = length - truncate_string.length
+    if $KCODE == "NONE"
+      self.length > length ? self[0...l] + truncate_string : self
+    else
+      chars = self.split(//)
+      chars.length > length ? chars[0...l].join + truncate_string : self
+    end
+  end
+  
+  def truncate!(length = 30, truncate_string = "...")
+    self.replace(self.truncate(length, truncate_string))
+  end
+  
+end
+# require 'digest'
+# class String
+#   
+#   # Maps to Mack::Utils::Inflector.instance.pluralize
+#   def plural
+#     Mack::Utils::Inflector.instance.pluralize(self)
+#   end
+#   
+#   # Maps to Mack::Utils::Inflector.instance.singularize
+#   def singular
+#     Mack::Utils::Inflector.instance.singularize(self)
+#   end
+#   
+
+#   
+#   
+#   def underscore
+#     camel_cased_word = self.dup
+#     camel_cased_word.to_s.gsub(/::/, '/').
+#       gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+#       gsub(/([a-z\d])([A-Z])/,'\1_\2').
+#       tr("-", "_").
+#       downcase
+#   end
+#   
+#   def starts_with?(x)
+#     self.match(/^#{x}/) ? true : false
+#   end
+#   
+#   def ends_with?(x)
+#     self.match(/#{x}$/) ? true : false
+#   end
+#   
+#   # Returns "is" or "are" based on the number, i.e. "i=6; There #{isare(i)} #{i} topics here."
+#   def self.pluralize_word(num, vals = ["is", "are"])
+#     return vals[0] if num.to_i==1
+#     return vals[1]
+#   end
+#   
+#   def remove(val)
+#     gsub(val, '')
+#   end
+#   
+#   def remove!(val)
+#     gsub!(val, '')
+#   end
+#   
+ 
+#   
+#   def truncate(length = 30, truncate_string = "...")
+#     if self.nil? then return end
+#     l = length - truncate_string.length
+#     if $KCODE == "NONE"
+#       self.length > length ? self[0...l] + truncate_string : self
+#     else
+#       chars = self.split(//)
+#       chars.length > length ? chars[0...l].join + truncate_string : self
+#     end
+#   end
+#   
+#   def truncate!(length = 30, truncate_string = "...")
+#     self.replace(self.truncate(length, truncate_string))
+#   end
+#   
+#   def capitalize_all_words
+#     self.gsub(/\b\w/) {|s| s.upcase}
+#   end
+#   
+#   def capitalize_all_words!
+#     self.replace(self.capitalize_all_words)
+#   end
+#   
+#   # keep adding on to this whenever it becomes apparent that unsafe strings
+#   # could get passed through into the database
+#   def sql_safe_str
+#     if !self.nil?
+#       self.gsub(/[\']/, "\'\'")
+#     end
+#   end
+#   
+#   def sql_safe_str! 
+#     self.replace(self.sql_safe_str)
+#   end
+#   
+# end

data/lib/extensions/symbol.rb

@@ -0,0 +1,7 @@
+class Symbol
+  
+  def methodize
+    self.to_s.methodize
+  end
+  
+end

data/lib/mack-facets.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'digest'
+require 'facets'
+require 'facets/ruby'
+require 'facets/style'
+require 'facets/blank'
+require 'facets/hash'
+require 'facets/hash/symbolize_keys'
+require 'facets/hash/stringify_keys'
+require 'facets/module'
+require 'facets/infinity'
+require 'english/inflect'
+require 'english/numerals'
+[:inflector, :inflections, :options_merger].each do |k|
+  path = File.join File.dirname(__FILE__), "utils", "#{k}"
+  #puts "requiring #{path}"
+  require path
+end
+
+[:array, :class, :hash, :kernel, :math, :module, :object, :string, :symbol].each do |k|
+  path = File.join File.dirname(__FILE__), "extensions", "#{k}"
+  #puts "requiring #{path}"
+  require path
+end
+
+[:numerals, :inflect].each do |k|
+  path = File.join File.dirname(__FILE__), "english_extensions", "#{k}"
+  #puts "requiring #{path}"
+  require path
+end
+

data/lib/utils/inflections.rb

@@ -0,0 +1,63 @@
+require File.join(File.dirname(__FILE__), "inflector")
+# Default inflections. This is taken from Jeremy McAnally's great Rails plugin, acts_as_good_speeler. Thanks Jeremy! http://www.jeremymcanally.com/
+Mack::Utils::Inflector.inflections do |inflect|
+  # inflect.plural(/$/, 's')
+  inflect.plural(/s$/i, 's')
+  inflect.plural(/(bu)s$/i, '\1ses')
+  inflect.plural(/(stimul|hippopotam|octop|vir|syllab|foc|alumn|fung|radi)us$/i, '\1i')
+  inflect.plural(/(ax|test)is$/i, '\1es')
+  inflect.plural(/(alias|status)$/i, '\1es')
+  inflect.plural(/(buffal|tomat|torped)o$/i, '\1oes')
+  inflect.plural(/([dti])um$/i, '\1a')
+  inflect.plural(/sis$/i, 'ses')
+  inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+  inflect.plural(/(hive)$/i, '\1s')
+  inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+  inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+  inflect.plural(/(matr|append|vert|ind)ix|ex$/i, '\1ices')
+  inflect.plural(/([m|l])ouse$/i, '\1ice')
+  inflect.plural(/^(ox)$/i, '\1en')
+  inflect.plural(/(quiz)$/i, '\1zes')
+  inflect.plural(/(phenomen|criteri)on$/i, '\1a')
+  inflect.plural(/^(?!(.*hu|.*ger|.*sha))(.*)(wom|m)an$/i, '\2\3en')
+  inflect.plural(/(curricul|bacteri|medi)um$/i, '\1a')
+  inflect.plural(/(nebul|formul|vit|vertebr|alg|alumn)a$/i, '\1ae')
+
+  # inflect.singular(/s$/i, '')
+  inflect.singular(/(n)ews$/i, '\1ews')
+  inflect.singular(/([dti])a$/i, '\1um')
+  inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
+  inflect.singular(/(^analy|cri|empha)ses$/i, '\1sis')
+  inflect.singular(/([^f])ves$/i, '\1fe')
+  inflect.singular(/(hive)s$/i, '\1')
+  inflect.singular(/(tive)s$/i, '\1')
+  inflect.singular(/(bus)es$/i, '\1')
+  inflect.singular(/(o)es$/i, '\1')
+  inflect.singular(/(shoe)s$/i, '\1')
+  inflect.singular(/(test|ax)es$/i, '\1is')
+  inflect.singular(/(stimul|hippopotam|octop|vir|syllab|foc|alumn|fung|radi)i$/i, '\1us')
+  inflect.singular(/(alias|status)es$/i, '\1')
+  inflect.singular(/^(ox)en$/i, '\1')
+  inflect.singular(/(vert|ind)ices$/i, '\1ex')
+  inflect.singular(/(matr|append)ices$/i, '\1ix')
+  inflect.singular(/(quiz)zes$/i, '\1')
+  inflect.singular(/(phenomen|criteri)a$/i, '\1on')
+  inflect.singular(/(.*)(wo|m)en$/i, '\1\2an')
+  inflect.singular(/(medi|curricul|bacteri)a$/i, '\1um')
+  inflect.singular(/(nebula|formula|vita|vertebra|alga|alumna)e$/i, '\1')
+  inflect.singular(/^(.*)ookies$/, '\1ookie')
+  inflect.singular(/(.*)ss$/, '\1ss')
+  inflect.singular(/(.*)ies$/, '\1y')
+
+  inflect.irregular('person', 'people')
+  inflect.irregular('child', 'children')
+  inflect.irregular('sex', 'sexes')
+  inflect.irregular('move', 'moves')
+  inflect.irregular('tooth', 'teeth')
+  inflect.irregular('die', 'dice')
+  inflect.irregular('talisman', 'talismans')
+  inflect.irregular('penis', 'penises')
+  inflect.irregular('christmas', 'christmases')
+  inflect.irregular('knowledge', 'knowledge')
+  inflect.irregular('quiz', 'quizzes')
+end

data/lib/utils/inflector.rb

@@ -0,0 +1,99 @@
+require 'singleton'
+require File.join(File.dirname(__FILE__), "..", "english_extensions", 'inflect')
+module Mack # :nodoc:
+  module Utils # :nodoc:
+    # This class is used to deal with inflection strings. This means taken a string and make it plural, or singular, etc...
+    # Inflection rules can be added very easy, and are checked from the bottom up. This means that the last rule is the first
+    # rule to be matched. The exception to this, kind of, is 'irregular' and 'uncountable' rules. The 'uncountable' rules are
+    # always checked first, then the 'irregular' rules, and finally either the 'singular' or 'plural' rules, depending on what
+    # you're trying to do. Within each of these sets of rules, the last rule in is the first rule matched.
+    # 
+    # Example:
+    #   Mack::Utils::Inflector.inflections do |inflect|
+    #     inflect.plural(/$/, 's')
+    #     inflect.plural(/^(ox)$/i, '\1en')
+    #     inflect.plural(/(phenomen|criteri)on$/i, '\1a')
+    #   
+    #     inflect.singular(/s$/i, '')
+    #     inflect.singular(/(n)ews$/i, '\1ews')
+    #     inflect.singular(/^(.*)ookies$/, '\1ookie')
+    #   
+    #     inflect.irregular('person', 'people')
+    #     inflect.irregular('child', 'children')
+    #   end
+    class Inflector
+      include Singleton
+      
+      # Adds a plural rule to the system.
+      # 
+      # Example:
+      #   Mack::Utils::Inflector.inflections do |inflect|
+      #     inflect.plural(/$/, 's')
+      #     inflect.plural(/^(ox)$/i, '\1en')
+      #     inflect.plural(/(phenomen|criteri)on$/i, '\1a')
+      #   end
+      def plural(rule, replacement)
+        English::Inflect.plural_rule(rule, replacement)
+      end
+      
+      # Adds a singular rule to the system.
+      # 
+      # Example:
+      #   Mack::Utils::Inflector.inflections do |inflect|
+      #     inflect.singular(/s$/i, '')
+      #     inflect.singular(/(n)ews$/i, '\1ews')
+      #     inflect.singular(/^(.*)ookies$/, '\1ookie')
+      #   end
+      def singular(rule, replacement)
+        English::Inflect.singular_rule(rule, replacement)
+      end
+      
+      # Adds a irregular rule to the system.
+      # 
+      # Example:
+      #   Mack::Utils::Inflector.inflections do |inflect|
+      #     inflect.irregular('person', 'people')
+      #     inflect.irregular('child', 'children')
+      #   end
+      def irregular(rule, replacement)
+        English::Inflect.rule(rule, replacement)
+        English::Inflect.word(rule, replacement)
+      end
+      
+      # Returns the singular version of the word, if possible.
+      # 
+      # Examples:
+      #   Mack::Utils::Inflector.instance.singularize("armies") # => "army"
+      #   Mack::Utils::Inflector.instance.singularize("people") # => "person"
+      #   Mack::Utils::Inflector.instance.singularize("boats") # => "boat"
+      def singularize(word)
+        English::Inflect.singular(word)
+      end
+      
+      # Returns the singular version of the word, if possible.
+      # 
+      # Examples:
+      #   Mack::Utils::Inflector.instance.pluralize("army") # => "armies"
+      #   Mack::Utils::Inflector.instance.pluralize("person") # => "people"
+      #   Mack::Utils::Inflector.instance.pluralize("boat") # => "boats"
+      def pluralize(word)
+        English::Inflect.plural(word)
+      end
+      
+      public
+      class << self
+        
+        # Yields up Mack::Utils::Inflector.instance
+        def inflections
+          if block_given?
+            yield Mack::Utils::Inflector.instance
+          else
+            Mack::Utils::Inflector.instance
+          end
+        end
+        
+      end
+      
+    end # Inflection
+  end # Utils
+end # Mack

data/lib/utils/options_merger.rb

@@ -0,0 +1,27 @@
+module Mack 
+  module Utils
+    class OptionMerger #:nodoc:
+      instance_methods.each do |method|
+        undef_method(method) if method !~ /^(__|instance_eval|class|object_id)/
+      end
+
+      def initialize(context, options)
+        @context, @options = context, options
+      end
+
+      private
+      def method_missing(method, *arguments, &block)
+        merge_argument_options! arguments
+        @context.send(method, *arguments, &block)
+      end
+
+      def merge_argument_options!(arguments)
+        arguments << if arguments.last.respond_to? :to_hash
+          @options.merge(arguments.pop)
+        else
+          @options.dup
+        end
+      end
+    end # OptionMerger
+  end # Utils
+end # Mack

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: mack-facets
+version: !ruby/object:Gem::Version 
+  version: 0.6.0
+platform: ruby
+authors: 
+- markbates
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-16 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: facets
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.4.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: english
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.2.0
+    version: 
+description: "mack-facets was developed by: markbates"
+email: mark@mackframework.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/english_extensions/inflect.rb
+- lib/english_extensions/numerals.rb
+- lib/extensions/array.rb
+- lib/extensions/class.rb
+- lib/extensions/hash.rb
+- lib/extensions/kernel.rb
+- lib/extensions/math.rb
+- lib/extensions/module.rb
+- lib/extensions/object.rb
+- lib/extensions/string.rb
+- lib/extensions/symbol.rb
+- lib/mack-facets.rb
+- lib/utils/inflections.rb
+- lib/utils/inflector.rb
+- lib/utils/options_merger.rb
+- README
+has_rdoc: true
+homepage: http://www.mackframework.com
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: magrathea
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: Ruby language extensions for Mack
+test_files: []
+