facets 2.5.2 → 2.6.0

data/lib/core/facets/integer/length.rb

@@ -0,0 +1,16 @@
+#
+# Calculate the number of digits in an integer.
+#
+# 1.length   #=> 1
+# 10.length  #=> 2
+# 100.length #=> 3
+#
+# CREDIT: Victor H. Goff III
+
+class Integer
+  # Returns the length of an integer as an integer.
+  def length
+    to_s.length
+  end
+end
+

data/lib/core/facets/kernel/state.rb

@@ -0,0 +1,50 @@
+module Kernel
+
+  def state(data=nil)
+    if state
+      instance_variables.each do |iv|
+        name = iv.to_s.sub(/^[@]/, '').to_sym
+        instance_variable_set(iv, data[name])
+      end
+    else
+      data = Hash.new
+      instance_variables.each do |iv|
+        name = iv.to_s.sub(/^[@]/, '').to_sym
+        data[name] = instance_variable_get(iv)
+      end
+      data
+    end
+  end
+
+end
+
+class Array
+  def state(data=nil)
+    data ? replace(data) : dup
+  end
+end
+
+class String
+  def state(data=nil)
+    data ? replace(data) : dup
+  end
+end
+
+class Hash
+  def state(data=nil)
+    data ? replace(data) : dup
+  end
+end
+
+class Struct
+  def state(data=nil)
+    if data
+      data.each_pair {|k,v| send(k.to_s + "=", v)}
+    else
+      data = Hash.new
+      each_pair{|k,v| data[k] = v}
+      data
+    end
+  end
+end
+

data/lib/core/facets/module/extend.rb

@@ -2,8 +2,8 @@ class Module
 
   alias_method :_extend, :extend
 
-  def extend(mod=nil, &blk)
-    _extend mod if mod
+  def extend(*mod, &blk)
+    _extend *mod unless mod.empty?
     _extend Module.new(&blk) if blk
   end
 

data/lib/core/facets/string/camelcase.rb

@@ -2,23 +2,47 @@ class String
 
   # Converts a string to camelcase.
   #
-  # By default camelcase convert to UpperCamelCase, If an argument
-  # is set to +false+, then camelcase will produce lowerCamelCase.
+  # By default camelcase leaves the first charcter of the string as given.
+  # If +first_letter+ is set to +:lower+ or +false+, then +#camelcase+ will
+  # produce lowerCamelCase. If it is set to +:upper+ or +true+ it will
+  # produce UpperCamelCase.
   #
-  # +camelcase+ also converts '/' to '::' which is useful for converting
+  # +#camelcase+ also converts '/' to '::' which is useful for converting
   # paths to namespaces.
   #
   # Examples
-  #   "camel_case".camelcase                    #=> "CamelCase"
-  #   "camel/case".camelcase                    #=> "Camel::Case"
-  #   "camel_case".camelcase(false)             #=> "camelCase"
+  #   "camel_case".camelcase             #=> "CamelCase"
+  #   "camel/case".camelcase             #=> "Camel::Case"
+  #   "camel_case".camelcase(false)      #=> "camelCase"
   #
-  def camelcase(upcase_first_letter=true)
-    up = upcase_first_letter
+  def camelcase(first_letter=nil)
+    case first_letter
+    when :upper, true
+      upper_camelcase
+    when :lower, false
+      lower_camelcase
+    else
+      str = dup
+      str.gsub!(/\/(.?)/){ "::#{$1.upcase}" }  # NOT SO SURE ABOUT THIS
+      str.gsub!(/(?:_+|-+)([a-z])/){ $1.upcase }
+      #str.gsub!(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+      str
+    end
+  end
+
+  def upper_camelcase
+    str = dup
+    str.gsub!(/\/(.?)/){ "::#{$1.upcase}" }  # NOT SO SURE ABOUT THIS
+    str.gsub!(/(?:_+|-+)([a-z])/){ $1.upcase }
+    str.gsub!(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+    str
+  end
+
+  def lower_camelcase
     str = dup
     str.gsub!(/\/(.?)/){ "::#{$1.upcase}" }  # NOT SO SURE ABOUT THIS
     str.gsub!(/(?:_+|-+)([a-z])/){ $1.upcase }
-    str.gsub!(/(\A|\s)([a-z])/){ $1 + $2.upcase } if up
+    str.gsub!(/(\A|\s)([a-z])/){ $1 + $2.downcase }
     str
   end
 

data/lib/core/facets/string/lowercase.rb

@@ -0,0 +1 @@
+require 'facets/string/uppercase'

data/lib/core/facets/string/methodize.rb

@@ -4,6 +4,16 @@ class String
   #
   #   My::CoolClass.name.methodize => "my__cool_class"
   #
+  #--
+  # Rails definition:
+  #
+  #    gsub(/\//, '__').
+  #    gsub(/::/, '__').
+  #    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+  #    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+  #    tr("-", "_").
+  #    downcase
+  #++
   def methodize
     gsub(/([A-Z]+)([A-Z])/,'\1_\2').
     gsub(/([a-z])([A-Z])/,'\1_\2').
@@ -14,4 +24,3 @@ class String
 
 end
 
-

data/lib/core/facets/string/modulize.rb

@@ -10,6 +10,14 @@ class String
   #   "method_name".modulize    #=> "MethodName"
   #   "method/name".modulize    #=> "Method::Name"
   #
+  #--
+  # Rails definition:
+  #
+  #    gsub(/__(.?)/){ "::#{$1.upcase}" }.
+  #    gsub(/\/(.?)/){ "::#{$1.upcase}" }.
+  #    gsub(/(?:_+)([a-z])/){ $1.upcase }.
+  #    gsub(/(^|\s+)([a-z])/){ $1 + $2.upcase }
+  #++
   def modulize
     gsub('__','/').
     gsub(/\/(.?)/){ "::#{$1.upcase}" }.

data/lib/core/facets/string/pathize.rb

@@ -4,6 +4,16 @@ class String
   #
   #   My::CoolClass.name.pathize  #=> "my/cool_class"
   #
+  #--
+  # Rails definition:
+  #
+  #    gsub(/__/, '/').
+  #    gsub(/::/, '/').
+  #    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+  #    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+  #    tr("-", "_").
+  #    downcase
+  #++
   def pathize
     gsub(/([A-Z]+)([A-Z])/,'\1_\2').
     gsub(/([a-z])([A-Z])/,'\1_\2').

data/lib/core/facets/string/snakecase.rb

@@ -7,10 +7,10 @@ class String
   # Examples
   #   "SnakeCase".snakecase           #=> "snake_case"
   #   "Snake-Case".snakecase          #=> "snake_case"
-  #   "SnakeCase::Errors".underscore  #=> "snake_case/errors"
+  #   "SnakeCase::Errors".snakecase   #=> "snake_case/errors"
   #
   def snakecase
-    gsub(/::/, '/').  # NOT SO SURE ABOUT THIS -T
+    gsub(/::/, '/').  # NOT SO SURE ABOUT THIS
     gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
     gsub(/([a-z\d])([A-Z])/,'\1_\2').
     tr("-", "_").

data/lib/core/facets/string/underscore.rb

@@ -0,0 +1,21 @@
+class String
+
+  # The reverse of +camelcase+. Makes an underscored of a camelcase string.
+  #
+  # Changes '::' to '/' to convert namespaces to paths.
+  #
+  # Examples
+  #   "SnakeCase".underscore           #=> "snake_case"
+  #   "Snake-Case".underscore          #=> "snake_case"
+  #   "SnakeCase::Errors".underscore   #=> "snake_case/errors"
+  #
+  def underscore
+    gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+
+end
+

data/lib/core/facets/string/uppercase.rb

@@ -0,0 +1,23 @@
+class String
+
+  # Upcase first letter.
+  #
+  # NOTE: One might argue that this method should behave the same as
+  # +#upcase+ and rather this behavior should be in place of +#captialize+.
+  # Probably so, but since Matz has already defined +#captialize+ the way
+  # it is, this name seems most fitting to the missing behavior.
+  #
+  def uppercase
+    str = to_s
+    str[0,1].upcase + str[1..-1]
+  end
+
+  # Downcase first letter.
+  #
+  def lowercase
+    str = to_s
+    str[0,1].downcase + str[1..-1]
+  end
+
+end
+

data/lib/more/facets/censor.rb

@@ -0,0 +1,97 @@
+# = TITLE:
+#
+#   Censor
+#
+# = DESCRIPTION:
+#
+#   Reusable class for filtering and rewriting strings.
+#
+# = AUTHORS:
+#
+#   - George Moschovitis
+#   - Trans
+#
+
+# = Censor
+#
+# Formaly known as TextFilter, this class allows one to define a
+# resuable text filter. This is useful for removing or replacing
+# cursewords or senstive information from user input.
+#
+class Censor
+
+  # Abritraty rules.
+  attr :rules
+
+  # Word-oriented rules.
+  attr :word_rules
+
+  # New Censor object.
+  #
+  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
+

data/lib/more/facets/minitar.rb

@@ -4,7 +4,7 @@
 #
 # Archive::Tar::Minitar is a pure-Ruby library and command-line
 # utility that provides the ability to deal with POSIX tar(1) archive
-# files. The implementation is based heavily on Mauricio Fern�dez's
+# files. The implementation is based heavily on Mauricio Ferna'ndez's
 # implementation in rpa-base, but has been reorganised to promote
 # reuse in other projects.
 #
@@ -16,7 +16,7 @@
 # NOTE::: support for typeflags 1 and 2 is not yet implemented in this
 #         version.
 #
-# This release is version 0.5.1. The library can only handle files and
+# This release is version 0.5.2. The library can only handle files and
 # directories at this point. A future version will be expanded to
 # handle symbolic links and hard links in a portable manner. The
 # command line utility, minitar, can only create archives, extract
@@ -64,16 +64,16 @@
 #
 # == Version
 #
-#   0.5.1
+#   0.5.2
 #
 # == Authors
 #
-# * Mauricio Julio Fern�dez Pradier
+# * Mauricio Julio Ferna'ndez Pradier
 # * Austin Ziegler
 #
 # == Copying
 #
-# Copyright 2004 Mauricio Julio Fern�dez Pradier and Austin Ziegler
+# Copyright 2004 Mauricio Julio Ferna'ndez Pradier and Austin Ziegler
 #
 # This program is based on and incorporates parts of RPA::Package from
 # rpa-base (lib/rpa/package.rb and lib/rpa/util.rb) by Mauricio and
@@ -227,10 +227,10 @@ end
 require 'fileutils'
 require 'find'
 
-  # = Archive::Tar::Minitar 0.5.1
+  # = Archive::Tar::Minitar 0.5.2
   # Archive::Tar::Minitar is a pure-Ruby library and command-line
   # utility that provides the ability to deal with POSIX tar(1) archive
-  # files. The implementation is based heavily on Mauricio Fern�dez's
+  # files. The implementation is based heavily on Mauricio Ferna'ndez's
   # implementation in rpa-base, but has been reorganised to promote
   # reuse in other projects.
   #
@@ -242,7 +242,7 @@ require 'find'
   # NOTE::: support for typeflags 1 and 2 is not yet implemented in this
   #         version.
   #
-  # This release is version 0.5.1. The library can only handle files and
+  # This release is version 0.5.2. The library can only handle files and
   # directories at this point. A future version will be expanded to
   # handle symbolic links and hard links in a portable manner. The
   # command line utility, minitar, can only create archives, extract
@@ -288,20 +288,20 @@ require 'find'
   #   end
   #
   # == Copyright
-  # Copyright 2004 Mauricio Julio Fern�dez Pradier and Austin Ziegler
+  # Copyright 2004 Mauricio Julio Ferna'ndez Pradier and Austin Ziegler
   #
   # This program is based on and incorporates parts of RPA::Package from
   # rpa-base (lib/rpa/package.rb and lib/rpa/util.rb) by Mauricio and
   # has been adapted to be more generic by Austin.
   #
   # 'minitar' contains an adaptation of Ruby/ProgressBar by Satoru
-  # Takabayashi <satoru@namazu.org>, copyright  2001 - 2004.
+  # Takabayashi <satoru@namazu.org>, copyright 2001 - 2004.
   #
   # This program is free software. It may be redistributed and/or
   # modified under the terms of the GPL version 2 (or later) or Ruby's
   # licence.
 module Archive::Tar::Minitar
-  VERSION = "0.5.1"
+  VERSION = "0.5.2"
 
     # The exception raised when a wrapped data stream class is expected to
     # respond to #rewind or #pos but does not.

data/lib/more/facets/platform.rb

@@ -188,5 +188,52 @@ class Platform
 
   CURRENT = 'current'
 
+  # Determine byte order of underlying machine.
+  def byte_order
+    ByteOrder.byte_order
+  end
+
+  def little_endian?
+    ByteOrder.little_endian?
+  end
+
+  def big_endian?
+    ByteOrder.big_endian?
+  end
+
+  # Copyright (c) 2003 Michael Neumann
+  module ByteOrder
+    Native    = :Native
+    BigEndian = Big = Network = :BigEndian
+    LittleEndian = Little = :LittleEndian
+
+    # examines the byte order of the underlying machine
+    def byte_order
+      if [0x12345678].pack("L") == "\x12\x34\x56\x78"
+        BigEndian
+      else
+        LittleEndian
+      end
+    end
+
+    alias_method :byteorder, :byte_order
+
+    def little_endian?
+      byte_order == LittleEndian
+    end
+
+    def big_endian?
+      byte_order == BigEndian
+    end
+
+    alias_method :little?, :little_endian?
+    alias_method :big?, :big_endian?
+    alias_method :network?, :big_endian?
+
+    module_function :byte_order, :byteorder
+    module_function :little_endian?, :little?
+    module_function :big_endian?, :big?, :network?
+  end
+
 end