facets 2.8.2 → 2.8.3

data/lib/core/facets/struct/attributes.rb

@@ -1,11 +1,15 @@
 class Struct
 
-  # Returns a hash containing the names and values for all instance variables in the Struct.
+  # Returns a hash containing the names and values
+  # for all instance settings in the Struct.
+  #
+  # This will eventually be deprecated in favor of #to_h.
+
   def attributes
     h = {}
     each_pair { |k,v| h[k] = v }
     h
   end
 
-end # class Struct
+end
 

data/lib/core/facets/symbol/op_div.rb

@@ -0,0 +1,19 @@
+class Symbol
+
+  # Join with _path_ as a file path.
+  #
+  #   :merb / "core_ext"           #=> "merb/core_ext"
+  #   :merb / :core_ext / :string  #=> "merb/core_ext/string"
+  #
+  # @param [#to_s] path The path component(s) to append.
+  #
+  # @return [String] The receiver (as path string), concatenated with _path_.
+  #
+  # @api public
+
+  def /(path)
+    File.join(to_s, path.to_s)
+  end
+
+end
+

data/lib/core/facets/to_hash.rb

@@ -318,3 +318,15 @@ class Enumerator
 
 end
 
+class Struct
+
+  # Returns a hash containing the names and values
+  # for all instance settings in the Struct.
+  def to_h
+    h = {}
+    each_pair{ |k,v| h[k] = v }
+    h
+  end
+
+end
+

data/lib/more/facets/casting_hash.rb

@@ -0,0 +1,172 @@
+# CastingHash is just like Hash, except that all keys and values
+# are passed through casting procedures.
+#--
+# TODO: Handle default_proc.
+#++
+class CastingHash < Hash
+
+  # Default key conversion procedure.
+  KEY_PROC = lambda{ |x| x } #.to_s }
+
+  # Default value conversion procedure.
+  VAL_PROC = lambda{ |x| x }
+
+  #
+  def self.[](hash)
+    s = new
+    hash.each{ |k,v| s[k] = v }
+    s
+  end
+
+  #
+  def initialize(hash, value_cast=nil, &key_cast)
+    @key_proc   = key_cast           || KEY_PROC
+    @value_proc = value_cast.to_proc || VAL_PROC
+    hash.each{ |k,v| self[k] = v }
+  end
+
+  #
+  def key_proc
+    @key_proc
+  end
+
+  #
+  def key_proc=(proc)
+    @key_proc = proc.to_proc
+  end
+
+  #
+  def value_proc
+    @value_proc
+  end
+
+  #
+  def value_proc=(proc)
+    @value_proc = proc.to_proc
+  end
+
+  #
+  def [](k)
+    super(key_proc[k])
+  end
+
+  #
+  def []=(k,v)
+    super(key_proc[k], value_proc[v])
+  end
+
+  #
+  def <<(other)
+    case other
+    when Hash
+      super(cast(other))
+    when Array
+      self[other[0]] = other[1]
+    else
+      raise ArgumentError
+    end
+  end
+
+  def fetch(k)
+    super(key_proc[k])
+  end
+
+  #
+  def store(k, v)
+    super(key_proc[k], value_proc[v])
+  end
+
+  #
+  def key?(k)
+    super(key_proc[k])
+  end
+
+  #
+  def has_key?(k)
+    super(key_proc[k])
+  end
+
+  # Synonym for Hash#rekey, but modifies the receiver in place (and returns it).
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }.to_stash
+  #   foo.rekey!{ |k| k.upcase }  #=>  { "NAME"=>"Gavin", "WIFE"=>:Lisa }
+  #   foo.inspect                 #=>  { "NAME"=>"Gavin", "WIFE"=>:Lisa }
+  #
+  def rekey!(*args, &block)
+    # for backward comptability (DEPRECATE?).
+    block = args.pop.to_sym.to_proc if args.size == 1
+    if args.empty?
+      block = lambda{|k| k} unless block
+      keys.each do |k|
+        nk = block[k]
+        self[nk] = delete(k) #if nk
+      end
+    else
+      raise ArgumentError, "3 for 2" if block
+      to, from = *args
+      self[to] = delete(from) if has_key?(from)
+    end
+    self
+  end
+
+  #
+  def rekey(*args, &block)
+    dup.rekey!(*args, &block)
+  end
+
+  #
+  def delete(k)
+    super(key_proc[k])
+  end
+
+  #
+  def update(other)
+    super(cast(other))
+  end
+
+  # Same as #update.
+  def merge!(other)
+    super(cast(other))
+  end
+
+  #
+  def replace(other)
+    super(cast(other))
+  end
+
+  #
+  def values_at(*keys)
+    super(keys.map(&key_proc))
+  end
+
+  #
+  def to_hash
+    h = {}; each{ |k,v| h[k] = v }; h
+  end
+
+  #
+  alias_method :to_h, :to_hash
+
+  private
+
+    #
+    def cast(hash)
+      h
+      hash.each do |k,v| 
+        h[key_proc[k]] = value_proc[v]
+      end
+      h
+    end
+
+end
+
+
+class Hash
+
+  # Convert a Hash to a Stash object.
+  def to_casting_hash(value_cast=nil, &key_cast)
+    CastingHash.new(self, value_cast, &key_cast)
+  end
+
+end
+

data/lib/more/facets/pathname.rb

@@ -25,6 +25,10 @@ require 'facets/file/rootname'
 
 class Pathname
 
+  # Alias #to_s to #to_str when #to_str is not defined.
+  #
+  alias_method(:to_str, :to_s) unless method_defined?(:to_str)
+
   # Alternate to Pathname#new.
   #
   #   Pathname['/usr/share']
@@ -148,6 +152,38 @@ class Pathname
     ::FileUtils.outofdate?(to_s, sources.flatten)
   end
 
+  # Recursively visit a directory located by its path, yielding each resource
+  # as its full matching pathname object. If called on a file, yield the file.
+  #
+  # call-seq:
+  #   visit => yield each file
+  #   visit(all: true) => yield visited directories as well
+  #   visit(hidden: true) => yield hidden files and directories as well
+  #
+  # Example use case:
+  #
+  #   # get rid of any file but *.haml within app/**/*
+  #   Pathname.new("app").visit do |f|
+  #     FileUtils.rm_f(f) unless f.to_s =~ /\.haml$/
+  #     puts "!!! deleting #{f}"
+  #   end 
+  #
+  # CREDIT: Jean-Denis Vauguet
+  def visit(options = {:all => false, :hidden => false})
+    if self.directory?
+      children.each do |entry|
+        next if entry.basename.to_s[0] == "." && !options[:hidden]
+        yield(entry) unless entry.directory? && !options[:all]
+        #entry.visit(:all => options[:all]) { |sub_entry| yield sub_entry } if entry.directory?
+        entry.visit(:all => options[:all], :hidden => options[:hidden]) do |sub_entry|
+          yield(sub_entry)
+        end if entry.directory?
+      end
+    else
+      yield self
+    end
+  end
+
 #   # Already included in 1.8.4+ version of Ruby (except for inclusion flag)
 #   if not instance_methods.include?(:ascend)
 #

data/lib/more/facets/prepend.rb

@@ -0,0 +1,57 @@
+# :title:       Prepend
+# :copyright:   Copyright (c) 2005 Thomas Sawyer
+# :license:     Ruby License
+# :description: Prepend a module to another module, or to a class.
+
+# = Prepend
+#
+# This is a module prepend system, which provides an elegant
+# way to prepend code to the class hierarchy rather then append
+# it (a la #include).
+#
+#   class C
+#     def f
+#       "f"
+#     end
+#   end
+#
+#   module M
+#     def f
+#       '{' + super + '}'
+#     end
+#   end
+#
+#   class C
+#     prepend M
+#   end
+#
+#   c = C.new
+#   c.f  #=> "{f}"
+#
+# This works by overriding Class#new so that all prepended modules
+# extend new instances of the class upon instantiation.
+#
+# If needed the original #new method has been aliased as #init.
+
+class Class
+
+  #
+  def prepend(*mods)
+    @prepend ||= []
+    @prepend.concat(mods)
+    @prepend
+  end
+
+  alias_method :init, :new
+
+  def new(*args, &blk)
+    o = allocate
+    prepend.each do |mod|
+      o.extend(mod)
+    end
+    o.__send__(:initialize, *args, &blk) #if private_method_defined?(:initialize)
+    o
+  end
+
+end
+

data/lib/more/facets/random.rb

@@ -53,7 +53,7 @@ require 'facets/string/shatter'
 module Random
 
   class << self
-    # alias to Kernel method #rand.
+    # Alias for Kernel#rand.
     alias_method :number, :rand
     public :number
   end
@@ -79,6 +79,8 @@ module Random
     end
   end
 
+  #
+
   module Object
 
     # Random generator that returns true or false.
@@ -106,9 +108,23 @@ module Random
     #   (1..4).at_rand           #=> 2
     #   (1..4).at_rand           #=> 4
     #
+    #   (1.5..2.5).at_rand       #=> 2.06309842754533
+    #   (1.5..2.5).at_rand       #=> 1.74976944931541
+    #
+    #   ('a'..'z').at_rand       #=> 'q'
+    #   ('a'..'z').at_rand       #=> 'f'
+    #
+    # CREDIT: Lavir the Whiolet
+
     def at_rand
-      array = to_a
-      array.at(Random.number(array.size))
+      if first.respond_to?(:succ)
+        to_a.at_rand
+      elsif Numeric===first && Numeric===last
+        number = (last - first) * Random.number + first
+        (number == last && exclude_end?) ? first : number
+      else
+        nil
+      end
     end
 
   end

data/lib/more/facets/roman.rb

@@ -1,174 +1,67 @@
-# = TITLE:
-#   Roman Numerals
-#
-# = SYNOPSIS:
-#   Generates roman numerals from integers and vice-versa.
-#
-# = NOTES:
-#   A response to Ruby Quiz of the Week #22 - Roman Numerals [ruby-talk:132925]
-#
-# = AUTHORS:
-#   - Dave Burt <dave at burt.id.au>
-#   - Trans
-
-module English #:nodoc:
-
-# Contains methods to convert integers to roman numeral strings and vice-versa.
-
-module RomanNumerals
-
-  # The largest integer representable as a roman
-  # numerable by this module.
-
-  MAX = 3999
-
-  # Stolen from O'Reilly's Perl Cookbook 6.23. Regular Expression Grabbag.
-
-  REGEXP = /^M*(D?C{0,3}|C[DM])(L?X{0,3}|X[LC])(V?I{0,3}|I[VX])$/i
-
-  #
-
-  SYMBOLS = [  "M", "D", "C", "L", "X", "V", "I" ]
-  NUMBERS = [ 1000, 500, 100,  50,  10,   5,   1 ]
-
-
-  # Maps roman numeral digits to their integer values.
-  #   {
-  #     'I' => 1,
-  #     'V' => 5,
-  #     'X' => 10,
-  #     'L' => 50,
-  #     'C' => 100,
-  #     'D' => 500,
-  #     'M' => 1000,
-  #   }
-
-  TABLE = Hash[*SYMBOLS.zip(NUMBERS).flatten]
+class Integer
 
   #
-
-  PAIR_SYMBOLS = [ "CM", "CD", "XC", "XL", "IX", "IV", "I" ]
-  PAIR_NUMBERS = [ 900,  400,    90,   40,    9,    4,   1 ]
-
-  #   {
-  #     'CM' => 900,
-  #     'CD' => 400,
-  #     'XC' => 90,
-  #     'XL' => 40,
-  #     'IX' => 9,
-  #     'IV' => 4
-  #   }
-
-  PAIR_TABLE  = Hash[*PAIR_SYMBOLS.zip(PAIR_NUMBERS).flatten]
+  ROMAN_MAX = 3999
 
   #
+  ROMAN_VALUES = [
+    ["M", 1000],
+    ["CM", 900],
+    ["D",  500],
+    ["CD", 400],
+    ["C",  100],
+    ["XC",  90],
+    ["L",   50],
+    ["XL",  40],
+    ["X",   10],
+    ["IX",   9],
+    ["V",    5],
+    ["IV",   4],
+    ["I",    1]
+  ]
 
-  LOOKUP = TABLE.invert.merge(PAIR_TABLE.invert)
-
-
-  class << self
-
-  # Converts +integer+ to a roman numeral.
-
-  def from_integer(integer)
-    return nil if integer < 0 || integer > MAX
-
-    r = integer  # remainder
-    y = ''       # result
-
-    NUMBERS.each do |n|
-      while r >= n
-        r -= n
-        y += LOOKUP[n]
-      end
-      break if r <= 0
-    end
-
-    return y
-  end
-
-  alias_method :roman, :from_integer
-
-  # Converts +roman_string+, a roman numeral, to an integer
-
-  def to_integer(roman_string)
-    return nil unless roman_string.is_roman_numeral?
-
-    l = nil  # last
-    i = 0    # integer result
-
-    c = roman_string.to_s.upcase.split(//).reverse
-
-    c.each do |d|
-      if v = TABLE[d]
-        if l && l > v
-          i -= v
-        else
-          i += v
-        end
-        l = v
-      end
+  # Converts this integer to a roman numeral.
+  def roman
+    int = self
+    #return nil if integer > ROMAN_MAX
+    return "-#{(-int).roman}" if int < 0
+    return "" if int == 0
+    ROMAN_VALUES.each do |(i, v)|
+      return(i + (int-v).roman) if v <= int 
     end
-
-    return i
-  end
-
-  alias_method :arabic, :to_integer
-
-  # Returns true iif +string+ is a roman numeral.
-
-  def is_roman_numeral?(string)
-    REGEXP =~ string
-  end
-
   end
 
 end
 
-end # module English
-
 
-class Integer
-
-  def roman
-    English::RomanNumerals.roman(self) || ''
-  end
-
-  # Converts this integer to a roman numeral.
-
-  def to_s_roman
-    English::RomanNumerals.from_integer(self) || ''
-  end
-
-end
+class String
 
+  # Taken from O'Reilly's Perl Cookbook 6.23. Regular Expression Grabbag.
+  ROMAN = /^M*(D?C{0,3}|C[DM])(L?X{0,3}|X[LC])(V?I{0,3}|I[VX])$/i
 
-class String
+  #
+  ROMAN_VALUES = Integer::ROMAN_VALUES.inject({}){ |h,(r,a)| h[r] = a; h }
 
-  # Considers string a roman numeral numeral,
+  # Considers string a Roman numeral numeral,
   # and converts it to the corresponding integer.
-
-  def to_i_roman
-    English::RomanNumerals.to_integer(self)
+  def roman
+    roman = self
+    raise unless roman?
+    last = roman[-1,1]
+    roman.reverse.split('').inject(0) do |result, c|
+      if ROMAN_VALUES[c] < ROMAN_VALUES[last]
+        result -= ROMAN_VALUES[c]
+      else
+        last = c
+        result += ROMAN_VALUES[c]
+      end
+    end
   end
 
-  # Returns true iif the subject is a roman numeral.
-
-  def is_roman_numeral?
-    English::RomanNumerals.is_roman_numeral?(self)
+  # Returns true iif the subject is a valid Roman numeral.
+  def roman?
+    ROMAN =~ self
   end
 
 end
 
-
-# # Quiz solution: filter that swaps roman and arabic numbers
-# if __FILE__ == $0
-#   ARGF.each do |line|
-#     line.chomp!
-#     if line.is_roman_numeral?
-#       puts line.to_i_roman
-#     else
-#       puts line.to_i.to_s_roman
-#     end
-#   end
-# end