facets 2.7.0 → 2.8.0

data/lib/more/facets/plugin_manager.rb

@@ -0,0 +1,50 @@
+# = Plugin Manger
+#
+# Find plugins easily.
+#
+# NOTE: This is likely to be replaced with
+# a more generic means of finding libraries.
+#
+module PluginManager
+  extend self
+
+  # Find plugins, searching through standard $LOAD_PATH,
+  # Roll Libraries and RubyGems.
+  #
+  # +match+ is a file glob for finding plugins.
+  #
+  #   PluginManager.find('syckles/*')
+  #
+  def find(match)
+    plugins = []
+    # Standard $LOAD_PATH
+    $LOAD_PATH.uniq.each do |path|
+      list = Dir.glob(File.join(path, match))
+      #dirs = dirs.select{ |d| File.directory?(d) }
+      list = list.map{ |d| d.chomp('/') }
+      plugins.concat(list)
+    end
+    # ROLL (load latest versions only)
+    if defined?(::Roll)
+      ::Roll::Library.ledger.each do |name, lib|
+        lib = lib.sort.first if Array===lib
+        lib.load_path.each do |path|
+          find = File.join(lib.location, path, match)
+          list = Dir.glob(find)
+          list = list.map{ |d| d.chomp('/') }
+          plugins.concat(list)
+        end
+      end
+    end
+    # RubyGems (load latest versions only)
+    if defined?(::Gem)
+      Gem.latest_load_paths do |path|
+        list = Dir.glob(File.join(path, match))
+        list = list.map{ |d| d.chomp('/') }
+        plugins.concat(list)
+      end
+    end
+    plugins
+  end
+
+end

data/lib/more/facets/random.rb

@@ -2,9 +2,9 @@
 #
 # Randomization core extension methods.
 #
-# This library extends Object, Array, String and Hash with randomization
+# This library extends Object, Array, String, Hash, and Range with randomization
 # methods. Most of the methods are of one of two kinds. Either they "pick"
-# a random element from the reciever or they randomly "shuffle" the reciever.
+# a random element from the reciever or they randomly "shuffle" the receiver.
 #
 # The most common example is Array#shuffle, which simply randmomizes the
 # order of an array's elements.
@@ -66,6 +66,8 @@ module Random
   def self.append_features(mod)
     if mod == ::Object
       mod.send(:include, Random::Object)
+    elsif mod == ::Range
+      mod.send(:include, Random::Range)
     elsif mod == ::Array
       mod.send(:include, Random::Array)
     elsif mod == ::Hash
@@ -97,9 +99,25 @@ module Random
 
   #
 
+  module Range
+
+    # Return a random element from the range.
+    #
+    #   (1..4).at_rand           #=> 2
+    #   (1..4).at_rand           #=> 4
+    #
+    def at_rand
+      array = to_a
+      array.at(Random.number(array.size))
+    end
+
+  end
+
+  #
+
   module Array
 
-    # Return a random element of the array.
+    # Return a random element from the array.
     #
     #   [1, 2, 3, 4].at_rand           #=> 2
     #   [1, 2, 3, 4].at_rand           #=> 4
@@ -437,6 +455,10 @@ class Object
   include Random
 end
 
+class Range
+  include Random
+end
+
 class Array
   include Random
 end

data/lib/more/facets/roman.rb

@@ -0,0 +1,174 @@
+# = 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]
+
+  #
+
+  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]
+
+  #
+
+  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
+    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
+
+  # Considers string a roman numeral numeral,
+  # and converts it to the corresponding integer.
+
+  def to_i_roman
+    English::RomanNumerals.to_integer(self)
+  end
+
+  # Returns true iif the subject is a roman numeral.
+
+  def is_roman_numeral?
+    English::RomanNumerals.is_roman_numeral?(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

data/lib/more/facets/semaphore.rb

@@ -0,0 +1,92 @@
+# = Semaphore
+#
+# Technically a semaphore is simply an integer variable which
+# has an execution queue associated with it.
+#
+# == Authors
+#
+# * Fukumoto
+#
+# = Copying
+#
+# Copyright (c) 2005 Fukumoto
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+
+# = Semaphore
+#
+# Technically a semaphore is simply an integer variable which
+# has an execution queue associated with it.
+#
+class Semaphore
+
+  def initialize(initvalue = 0)
+    @counter = initvalue
+    @waiting_list = []
+  end
+
+  def wait
+    Thread.critical = true
+    if (@counter -= 1) < 0
+      @waiting_list.push(Thread.current)
+      Thread.stop
+    end
+    self
+  ensure
+    Thread.critical = false
+  end
+
+  def signal
+    Thread.critical = true
+    begin
+      if (@counter += 1) <= 0
+        t = @waiting_list.shift
+        t.wakeup if t
+      end
+    rescue ThreadError
+      retry
+    end
+    self
+  ensure
+    Thread.critical = false
+  end
+
+  alias_method( :down, :wait )
+  alias_method( :up,   :signal )
+  alias_method( :p,    :wait )
+  alias_method( :v,    :signal )
+
+  def exclusive
+    wait
+    yield
+  ensure
+    signal
+  end
+
+  alias_method( :synchronize, :exclusive )
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+# TODO
+
+=begin #test
+
+  require 'test/unit'
+
+=end

data/lib/more/facets/shellwords.rb

@@ -1,24 +1,3 @@
-# = Shellwords Extended
-#
-# Adds extensions to Shellwords, namely #escape.
-#
-# == Authors
-#
-# * Thomas Sawuer
-#
-# == Copying
-#
-# Copyright (c) 2007 Thomas Sawyer
-#
-# Ruby License
-#
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.
-
 require 'shellwords'
 
 module Shellwords
@@ -34,56 +13,50 @@ module Shellwords
 
 end
 
-
 class Array
 
   # Convert an array into command line parameters.
   # The array is accepted in the format of Ruby
   # method arguments --ie. [arg1, arg2, ..., hash]
-
-  def to_shellwords
-    flags = (Hash===last ? pop : {})
-    flags = flags.to_shellwords
-    flags + ' ' + self #join(" ")
+  #
+  def shellwords
+    opts, args = *flatten.partition{ |e| Hash === e }
+    opts = opts.inject({}){ |m,h| m.update(h); m }
+    opts.shellwords + args
   end
 
-  def to_shell
-    to_shellwords.join(' ')
+  def shelljoin
+    Shellwords.shelljoin(shellwords)
   end
 
-  # Original name.
-  alias_method :to_console, :to_shell
 end
 
-
 class Hash
 
-  # Convert an array into command line parameters.
-  # The array is accepted in the format of Ruby
-  # method arguments --ie. [arg1, arg2, ..., hash]
-
-  def to_shellwords
-    flags = collect do |f,v|
+  #
+  def shellwords
+    argv = []
+    each do |f,v|
       m = f.to_s.size == 1 ? '-' : '--'
       case v
+      when false, nil
       when Array
-        v.collect{ |e| "#{m}#{f}='#{e}'" }.join(' ')
+        v.each do |e|
+          argv << %[#{m}#{f}="#{e}"]
+        end
       when true
-        "#{m}#{f}"
-      when false, nil
-        ''
+        argv << %[#{m}#{f}]
       else
-        "#{m}#{f}='#{v}'"
+        argv << %[#{m}#{f}="#{v}"]
       end
     end
-    flags #.join(" ")
+    argv
   end
 
-  def to_shell
-    to_shellwords.join(' ')
+  #
+  def shelljoin
+    shellwords.shelljoin
   end
 
-  # Original name.
-  alias_method :to_console, :to_shell
 end