mack-facets 0.8.1 → 0.8.2

data/lib/gems/english-0.3.1/lib/english/style_orm.rb

@@ -0,0 +1,143 @@
+module English
+  require 'english/inflect'
+  require 'english/style'
+
+  module StyleORM
+
+    #########################################################
+    # ACTIVE SUPPORT                                        #
+    #                                                       #
+    # The following were extracted from ActiveSupport's     #
+    # Inflector class. It seemed prudent to maintian this   #
+    # degree of compatbility, at least for the time being.  #
+    #########################################################
+
+    # By default, camelize converts strings to UpperCamelCase. If the
+    # argument to camelize is set to ":lower" then camelize produces
+    # lowerCamelCase.
+    #
+    # camelize will also convert '/' to '::' which is useful for
+    # converting paths to namespaces
+    #
+    #   "active_record".camelize               #=> "ActiveRecord"
+    #   "active_record".camelize(true)         #=> "activeRecord"
+    #   "active_record/errors".camelize        #=> "ActiveRecord::Errors"
+    #   "active_record/errors".camelize(true)  #=> "activeRecord::Errors"
+    #
+    def camelize(first_letter_in_uppercase = true)
+      if first_letter_in_uppercase
+        to_s.gsub(/\/(.?)/){ "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/){ $1.upcase }
+      else
+        lowercase_and_underscored = to_s
+        lowercase_and_underscored[0,1] + lowercase_and_underscored.camelize[1..-1]
+      end
+    end
+
+    # The reverse of +camelize+. Makes an underscored, lowercase form from
+    # the expression in the string.
+    #
+    # Changes '::' to '/' to convert namespaces to paths.
+    #
+    #   "ActiveRecord".underscore          #=> "active_record"
+    #   "ActiveRecord::Errors".underscore  #=> active_record/errors
+    #
+    def underscore
+      to_s.
+      gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+
+    # Replaces underscores with dashes in the string.
+    #
+    #   "puni_puni".dasherize  #=> "puni-puni"
+    #
+    def dasherize
+      to_s.gsub(/_/, '-')
+    end
+
+    # Create a class name from a plural table name like Rails does
+    # for table names to models. Note that this returns a string and
+    # not a Class. (To convert to an actual class follow classify
+    # with constantize.)
+    #
+    #   "egg_and_hams".classify  #=> "EggAndHam"
+    #   "posts".classify         #=> "Post"
+    #
+    # Singular names are not handled correctly:
+    #
+    #   "business".classify      #=> "Busines"
+    #
+    def classify
+      # strip out any leading schema name
+      to_s.sub(/.*\./, '').singularize.camelize
+    end
+
+    # Capitalizes the first word and turns underscores into spaces and strips _id.
+    # Like titleize, this is meant for creating pretty output.
+    #
+    #   "employee_salary".humanize    #=> "Employee salary"
+    #   "author_id".humanize          #=> "Author"
+    #
+    def humanize
+      to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+    end
+
+    # Create the name of a table like Rails does for models to table names.
+    # This method uses the pluralize method on the last word in the string.
+    #
+    #   "RawScaledScorer".tableize  #=> "raw_scaled_scorers"
+    #   "egg_and_ham".tableize      #=> "egg_and_hams"
+    #   "fancyCategory".tableize    #=> "fancy_categories"
+    #
+    def tableize
+      to_s.underscore.pluralize
+    end
+
+    # Capitalizes all the words and replaces some characters in the
+    # string to create a nicer looking title. Titleize is meant for
+    # creating pretty output. It is not used in the Rails internals.
+    #
+    # titleize is also aliased as as titlecase
+    #
+    #   "man from the boondocks".titleize   #=> "Man From The Boondocks"
+    #   "x-men: the last stand".titleize    #=> "X Men: The Last Stand"
+    #
+    def titleize
+      to_s.underscore.humanize.gsub(/\b('?[a-z])/){ $1.capitalize }
+    end
+
+    # Creates a foreign key name from a class name.
+    # +separate_id_with_underscore+ sets whether the method
+    # should put '_' between the name and 'id'.
+    #
+    #   "Message".foreign_key        #=> "message_id"
+    #   "Message".foreign_key(false) #=> "messageid"
+    #   "Admin::Post".foreign_key    #=> "post_id"
+    #
+    def foreign_key(separate_id_with_underscore = true)
+      to_s.demodulize.underscore + (separate_id_with_underscore ? "_id" : "id")
+    end
+
+  end
+
+  module StyleORM::Replace
+    def camelize!    ; replace(camelize)    ; end
+    def underscore!  ; replace(underscore)  ; end
+    def dasherize!   ; replace(dasherize)   ; end
+    def classify!    ; replace(classify)    ; end
+    def humanize!    ; replace(humanize)    ; end
+    def tableize!    ; replace(tableize)    ; end
+    def titleize!    ; replace(titleize)    ; end
+    def foreign_key! ; replace(foreign_key) ; end
+  end
+
+end
+
+class String #:nodoc:
+  include English::StyleORM
+  include English::StyleORM::Replace
+end
+

data/lib/gems/english-0.3.1/lib/english/textfilter.rb

@@ -0,0 +1,91 @@
+# = TITLE:
+#
+#   Text Filter
+#
+# = DESCRIPTION:
+#
+#   Reusable class for filtering and rewriting strings.
+#
+# = AUTHORS:
+#
+#   - George Moschovitis
+#   - Trans
+
+module English #:nodoc:
+
+  class Filter
+
+    attr :rules
+
+    attr :word_rules
+
+    #
+
+    def initialize()
+      @rules = []
+      @word_rules = []
+    end
+
+    # Create new rule. A rule consists of a string or regexp
+    # to match against.
+    #
+    # NOTE: The rules must be applied in order! So we cannot
+    # use a hash because the ordering is not guaranteed. So
+    # an array is used instead.
+
+    def rule(match, &edit)
+      edit = lambda{''} unless edit
+      @rules << [match, edit]
+    end
+
+    # Rules that apply only to words. This takes the regular
+    # expression and add word boundry matches to either side.
+    #
+    #   filter.word_rule(/damn/){ |w| 'darn' }
+    #
+    # Is equivalent to teh regular rule:
+    #
+    #   filter.rule(/\bdamn\b/){ |w| 'darn' }
+
+    def word_rule(match, &edit)
+      edit = lambda{''} unless edit
+      @word_rules << [/\b#{match}\b/, edit]
+    end
+
+    # Apply the set of rules (regular expression matches) to
+    # a string.
+
+    def filter(string)
+      rewritten_string = string.dup
+      rules.each do |match,edit|
+        rewritten_string.gsub!(match,edit)
+      end
+      return (rewritten_string or string)
+    end
+
+    alias_method :apply, :filter
+
+    # Is the string clear of any matching rules?
+    #
+    # Note that running a filter does not necessarily clear a
+    # a string of all matches, since the filter could apply
+    # edits that would also match the filter expressions.
+
+    def censored?(string)
+      case string
+      when *matches
+        false
+      else
+        true
+      end
+    end
+
+    #
+
+    def matches
+      rules.collect{ |match, modify| match }
+    end
+
+  end
+
+end

data/lib/gems/extlib-0.9.8/lib/extlib.rb

@@ -0,0 +1,56 @@
+require 'pathname'
+require 'rubygems'
+
+__DIR__ = File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH.unshift(__DIR__) unless $LOAD_PATH.include?(__DIR__)
+
+# for Pathname /
+require File.expand_path(File.join(__DIR__, 'extlib', 'pathname'))
+
+dir = Pathname(__FILE__).dirname.expand_path / 'extlib'
+
+require dir / "class.rb"
+require dir / "object"
+require dir / "object_space"
+
+require dir / "string"
+require dir / "symbol"
+require dir / "hash"
+require dir / "mash"
+require dir / "virtual_file"
+require dir / "logger"
+require dir / "time"
+require dir / "datetime"
+
+require dir / 'assertions'
+require dir / 'blank'
+require dir / 'boolean'
+require dir / 'inflection'
+require dir / 'lazy_array'
+require dir / 'module'
+require dir / 'nil'
+require dir / 'numeric'
+require dir / 'blank'
+require dir / 'simple_set'
+require dir / 'struct'
+require dir / 'symbol'
+
+Extlib.autoload("Hook", (dir / 'hook').to_s)
+Extlib.autoload("Pooling", (dir / 'pooling').to_s)
+
+module Extlib
+
+  def self.exiting= bool
+    if bool && Extlib.const_defined?("Pooling")
+      if Extlib::Pooling.scavenger?
+        Extlib::Pooling.scavenger.wakeup
+      end
+    end
+    @exiting = true
+  end
+
+  def self.exiting
+    @exiting
+  end
+
+end

data/lib/gems/extlib-0.9.8/lib/extlib/assertions.rb

@@ -0,0 +1,8 @@
+module Extlib
+  module Assertions
+    def assert_kind_of(name, value, *klasses)
+      klasses.each { |k| return if value.kind_of?(k) }
+      raise ArgumentError, "+#{name}+ should be #{klasses.map { |k| k.name } * ' or '}, but was #{value.class.name}", caller(2)
+    end
+  end
+end

data/lib/gems/extlib-0.9.8/lib/extlib/blank.rb

@@ -0,0 +1,59 @@
+class Object
+  # @return <TrueClass, FalseClass>
+  #
+  # @example [].blank?         #=>  true
+  # @example [1].blank?        #=>  false
+  # @example [nil].blank?      #=>  false
+  # 
+  # Returns true if the object is nil or empty (if applicable)
+  def blank?
+    nil? || (respond_to?(:empty?) && empty?)
+  end
+end # class Object
+
+class Numeric
+  # @return <TrueClass, FalseClass>
+  # 
+  # Numerics can't be blank
+  def blank?
+    false
+  end
+end # class Numeric
+
+class NilClass
+  # @return <TrueClass, FalseClass>
+  # 
+  # Nils are always blank
+  def blank?
+    true
+  end
+end # class NilClass
+
+class TrueClass
+  # @return <TrueClass, FalseClass>
+  # 
+  # True is not blank.  
+  def blank?
+    false
+  end
+end # class TrueClass
+
+class FalseClass
+  # False is always blank.
+  def blank?
+    true
+  end
+end # class FalseClass
+
+class String
+  # @example "".blank?         #=>  true
+  # @example "     ".blank?    #=>  true
+  # @example " hey ho ".blank? #=>  false
+  # 
+  # @return <TrueClass, FalseClass>
+  # 
+  # Strips out whitespace then tests if the string is empty.
+  def blank?
+    strip.empty?
+  end
+end # class String

data/lib/gems/extlib-0.9.8/lib/extlib/boolean.rb

@@ -0,0 +1,11 @@
+class TrueClass
+  def try_dup
+    self
+  end
+end
+
+class FalseClass
+  def try_dup
+    self
+  end
+end

data/lib/gems/extlib-0.9.8/lib/extlib/class.rb

@@ -0,0 +1,175 @@
+# Copyright (c) 2004-2008 David Heinemeier Hansson
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Allows attributes to be shared within an inheritance hierarchy, but where
+# each descendant gets a copy of their parents' attributes, instead of just a
+# pointer to the same. This means that the child can add elements to, for
+# example, an array without those additions being shared with either their
+# parent, siblings, or children, which is unlike the regular class-level
+# attributes that are shared across the entire hierarchy.
+class Class
+  # Defines class-level and instance-level attribute reader.
+  #
+  # @param *syms<Array> Array of attributes to define reader for.
+  # @return <Array[#to_s]> List of attributes that were made into cattr_readers
+  #
+  # @api public
+  #
+  # @todo Is this inconsistent in that it does not allow you to prevent
+  #   an instance_reader via :instance_reader => false
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      RUBY
+    end
+  end
+
+  # Defines class-level (and optionally instance-level) attribute writer.
+  #
+  # @param <Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
+  # @return <Array[#to_s]> List of attributes that were made into cattr_writers
+  #
+  # @api public
+  def cattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.flatten.each do |sym|
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+      RUBY
+      
+      unless options[:instance_writer] == false
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{sym}=(obj)
+            @@#{sym} = obj
+          end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level (and optionally instance-level) attribute accessor.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
+  # @return <Array[#to_s]> List of attributes that were made into accessors
+  #
+  # @api public
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+
+  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
+  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
+  #
+  # @api public
+  #
+  # @todo Do we want to block instance_reader via :instance_reader => false
+  # @todo It would be preferable that we do something with a Hash passed in
+  #   (error out or do the same as other methods above) instead of silently
+  #   moving on). In particular, this makes the return value of this function
+  #   less useful.
+  def class_inheritable_reader(*ivars)
+    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
+    
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}
+          return @#{ivar} if self == #{self} || defined?(@#{ivar})
+          ivar = superclass.#{ivar}
+          return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
+          @#{ivar} = ivar && !ivar.is_a?(Module) && !ivar.is_a?(Numeric) ? ivar.dup : ivar
+        end
+      RUBY
+      unless instance_reader == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}
+            self.class.#{ivar}
+          end
+        RUBY
+      end
+    end
+  end
+  
+  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
+  #
+  # @api public
+  #
+  # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it 
+  #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
+  def class_inheritable_writer(*ivars)
+    instance_writer = ivars.pop[:instance_writer] if ivars.last.is_a?(Hash)
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}=(obj)
+          @#{ivar} = obj        
+        end
+      RUBY
+      unless instance_writer == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}=(obj) self.class.#{ivar} = obj end
+        RUBY
+      end
+    end
+  end
+  
+  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to 
+  #   define inheritable accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
+  #
+  # @api public
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+end