facets 1.8.54 → 2.0.0

data/lib/more/facets/compare_on.rb

@@ -0,0 +1,143 @@
+# TITLE:
+#
+#   CompareOn
+#
+# SUMMARY:
+#
+#   Extension for making a class/module comparable.
+#
+# COPYRIGHT:
+#
+#   Copyright (c) 2005 Thomas Sawyer
+#
+# LICENSE:
+#
+#   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.
+#
+# TODOs:
+#
+#   - TODO Maybe improve on naming.
+
+
+#
+class Module
+
+  # Automatically generate sorting defintions base on attribute fields.
+  #
+  #   sort_on :a, :b
+  #
+  # _is equivalent to_
+  #
+  #   def <=>(o)
+  #     cmp = self.a <=> o.a; return cmp unless cmp == 0
+  #     cmp = self.b <=> o.b; return cmp unless cmp == 0
+  #     0
+  #   end
+  #
+  def sort_on(*fields)
+    code = %{def <=>(o)\n}
+    fields.each { |f|
+      code << %{cmp = ( @#{f} <=> o.instance_variable_get('@#{f}') );
+                return cmp unless cmp == 0\n}
+    }
+    code << %{0\nend; alias_method :cmp, :<=>;}
+    class_eval( code )
+    fields
+  end
+
+  # Should this be a standard alias?
+  alias_method :compare_on, :sort_on
+
+  # Deprecated usage
+  alias_method :sort_attributes, :sort_on
+
+  # Generates identity/key methods based on specified attributes.
+  #
+  #  equate_on :a, :b
+  #
+  # _is equivalent to_
+  #
+  #   def ==(o)
+  #     self.a == o.a && self.b == o.b
+  #   end
+  #
+  #   def eql?(o)
+  #     self.a.eql?(o.a) && self.b.eql?(o.b)
+  #   end
+  #
+  #   def hash()
+  #     self.a.hash ^ self.b.hash
+  #   end
+  #
+  def equate_on(*fields)
+    code = ""
+    code << "def ==(o) "   << fields.map {|f| "self.#{f} == o.#{f}" }.join(" && ")    << " end\n"
+    code << "def eql?(o) " << fields.map {|f| "self.#{f}.eql?(o.#{f})" }.join(" && ") << " end\n"
+    code << "def hash() "  << fields.map {|f| "self.#{f}.hash" }.join(" ^ ")          << " end\n"
+    class_eval( code )
+    fields
+  end
+
+  # Deprecated usage.
+  alias_method :key_attributes, :equate_on
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TestModuleCompare < Test::Unit::TestCase
+
+    def test_equate_on
+      c = Class.new
+      c.class_eval { attr_accessor :a, :b ; equate_on :a,:b }
+      c1,c2 = c.new,c.new
+      c1.a = 10; c1.b = 20
+      c2.a = 10; c2.b = 20
+      assert_equal( c1, c2 )
+      c1.a = 10; c1.b = 10
+      c2.a = 10; c2.b = 20
+      assert_not_equal( c1, c2 )
+      c1.a = 10; c1.b = 20
+      c2.a = 20; c2.b = 20
+      assert_not_equal( c1, c2 )
+    end
+
+    def test_sort_on
+      c = Class.new
+      c.class_eval {
+        def initialize(a,b)
+          @a=a; @b=b
+        end
+        sort_on :a,:b
+      }
+      a = [c.new(10,20),c.new(10,30)]
+      assert_equal( a, a.sort )
+      a = [c.new(10,30),c.new(10,20)]
+      assert_equal( a.reverse, a.sort )
+      a = [c.new(10,10),c.new(20,10)]
+      assert_equal( a, a.sort )
+      a = [c.new(20,10),c.new(10,10)]
+      assert_equal( a.reverse, a.sort )
+      a = [c.new(10,30),c.new(20,10)]
+      assert_equal( a, a.sort )
+    end
+
+  end
+
+=end

data/lib/more/facets/console.rb

@@ -0,0 +1,107 @@
+# Title:
+#   Console Utilities
+#
+# Author:
+#   - Thomas Sawyer
+#
+# License:
+#   Copyright (c) 2006,2007 Thomas Sawyer
+#   Ruby/GPL
+
+# ConsoleUtils provides methods that are
+# generally useful in the context of
+# creating console output.
+
+module ConsoleUtils
+
+  module_function
+
+  def println
+
+  end
+
+  # Convenient method to get simple console reply.
+
+  def ask(question, answers=nil)
+    print "#{question}"
+    print " [#{answers}] " if answers
+    until inp = $stdin.gets ; sleep 1 ; end
+    inp
+  end
+
+  # Convenience method for puts. Use this instead of
+  # puts when the output should be supressed if the
+  # global $QUIET option is set.
+
+  def say(statement)
+    puts statement #unless quiet? $QUIET
+  end
+
+  # Ask for a password. (FIXME: only for unix so far)
+
+  def password(msg=nil)
+    msg ||= "Enter Password: "
+    inp = ''
+
+    $stdout << msg
+
+    begin
+      system "stty -echo"
+      inp = gets.chomp
+    ensure
+      system "stty echo"
+    end
+
+    return inp
+  end
+
+  # Console screen width (taken from progress bar)
+
+  def screen_width(out=STDERR)
+    # FIXME: I don't know how portable it is.
+    default_width = ENV['COLUMNS'] || 80
+    begin
+      tiocgwinsz = 0x5413
+      data = [0, 0, 0, 0].pack("SSSS")
+      if out.ioctl(tiocgwinsz, data) >= 0 then
+        rows, cols, xpixels, ypixels = data.unpack("SSSS")
+        if cols >= 0 then cols else default_width end
+      else
+        default_width
+      end
+    rescue Exception
+      default_width
+    end
+  end
+
+  # Print a justified line with left and right entries.
+  #
+  # A fill option can be given to fill in any empty space
+  # between the two. And a ratio option can be given which defaults
+  # to 0.8 (eg. 80/20)
+
+  def print_justified(left, right, options={})
+    fill  = options[:fill] || '.'
+    fill  = ' ' if fill == ''
+    fill  = fill[0,1]
+
+    ratio = options[:ratio] || 0.8
+    ratio = 1 + ratio if ratio < 0
+
+    width = (@screen_width ||= screen_width) - 1
+
+    #l = (width * ratio).to_i
+    r = (width * (1 - ratio)).to_i
+    l = width - r
+
+    left  = left[0,l]
+    right = right[0,r]
+
+    str = fill * width
+    str[0,left.size] = left
+    str[width-right.size,right.size] = right
+
+    print str
+  end
+
+end

data/lib/more/facets/coroutine.rb

@@ -0,0 +1,176 @@
+# TITLE:
+#
+#   Coroutine
+#
+# SUMMARY:
+#
+#   This mixin solely depends on method read(n), which must be
+#   defined in the class/module where you mix in this module.
+#
+# COPYRIGHT:
+#
+#   Copyright (c) 2005 Florian Frank
+#
+# LICENSE:
+#
+#   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.
+#
+# AUTHORS:
+#
+#   - Florian Frank
+
+
+# = Coroutine
+#
+# Coroutines are program components like subroutines. Coroutines are more
+# generic and flexible than subroutines, but are less widely used in
+# practice. Coroutines were first introduced natively in Simula.
+# Coroutines are well suited for implementing more familiar program
+# components such as cooperative tasks, iterators, infinite lists, and pipes.
+#
+# == Usage
+#
+#   count = (ARGV.shift || 1000).to_i
+#   input = (1..count).map { (rand * 10000).round.to_f / 100}
+#
+#   Producer = Coroutine.new do |me|
+#     loop do
+#       1.upto(6) do
+#         me[:last_input] = input.shift
+#         me.resume(Printer)
+#       end
+#       input.shift # discard every seventh input number
+#     end
+#   end
+#   Printer = Coroutine.new do |me|
+#     loop do
+#       1.upto(8) do
+#         me.resume(Producer)
+#         if Producer[:last_input]
+#           print Producer[:last_input], "\t"
+#           Producer[:last_input] = nil
+#         end
+#         me.resume(Controller)
+#       end
+#       puts
+#     end
+#   end
+#
+#   Controller = Coroutine.new do |me|
+#     until input.empty? do
+#       me.resume(Printer)
+#     end
+#   end
+#
+#   Controller.run
+#
+
+class Coroutine
+
+  def initialize(data = {})
+    @data = data
+    callcc do |@continue|
+      return
+    end
+    yield self
+    stop
+  end
+
+  attr_reader :stopped
+
+  def run
+    callcc do |@stopped|
+      continue
+    end
+  end
+
+  def stop
+    @stopped.call
+  end
+
+  def resume(other)
+    callcc do |@continue|
+      other.continue(self)
+    end
+  end
+
+  def continue(from = nil)
+    @stopped = from.stopped if not @stopped and from
+    @continue.call
+  end
+
+  def [](name)
+    @data[name]
+  end
+
+  def []=(name, value)
+    @data[name] = value
+  end
+
+  protected :stopped, :continue
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  class TC_Coroutine < Test::Unit::TestCase
+
+    def test_run
+      assert_nothing_raised {
+
+        count = 100
+        input = (1..count).map { (rand * 10000).round.to_f / 100 }
+
+        @producer = Coroutine.new do |me|
+          loop do
+            1.upto(6) do
+              me[:last_input] = input.shift
+              me.resume(@printer)
+            end
+            input.shift  # discard every seventh input number
+          end
+        end
+
+        @printer = Coroutine.new do |me|
+          loop do
+            1.upto(8) do
+              me.resume(@producer)
+              if @producer[:last_input]
+                @producer[:last_input] = nil
+              end
+              me.resume(@controller)
+            end
+          end
+        end
+
+        @controller = Coroutine.new do |me|
+          until input.empty? do
+            me.resume(@printer)
+          end
+        end
+        @controller.run
+
+      }
+    end
+
+  end
+
+=end

data/lib/more/facets/crypt.rb

@@ -0,0 +1,214 @@
+# TITLE:
+#
+#   Crypt
+#
+# DESCRIPTION:
+#
+#   A pure ruby version of crypt(3), a salted one-way hashing of a password.
+#
+# COPYRIGHT:
+#
+#   Copyright (c) 2002 Poul-Henning Kamp
+#
+# LICENSE:
+#
+#   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.
+#
+# HISTORY:
+#
+#   Adapted by guillaume__dot__pierronnet_at__laposte__dot_net based on
+#   * http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/325204/index_txt
+#   which is based on FreeBSD src/lib/libcrypt/crypt.c 1.2
+#   * http://www.freebsd.org/cgi/cvsweb.cgi/~checkout~/src/lib/libcrypt/crypt.c?rev=1.2&content-type=text/plain
+#
+#   [Original License]
+#
+#   "THE BEER-WARE LICENSE" (Revision 42):
+#   <phk@login.dknet.dk> wrote this file.  As long as you retain this notice you
+#   can do whatever you want with this stuff. If we meet some day, and you think
+#   this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
+#
+# AUTHORS:
+#
+#   - Poul-Henning Kamp
+
+
+# = Crypt(3)
+#
+# A pure ruby version of crypt(3), a salted one-way hashing of a password.
+#
+module Crypt
+
+  ITOA64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+
+  # A pure ruby version of crypt(3), a salted one-way hashing of a password.
+  #
+  # Supported hashing algorithms are: md5, sha1, sha256, sha384, sha512, rmd160.
+  #
+  # Only the md5 hashing algorithm is standard and compatible with crypt(3), the others
+  # are not standard.
+  #
+  # Automatically generate a 8-bytes salt if nil.
+  #
+  # Output a length hashed and salted string with size of
+  # magic.size + salt.size + 23.
+
+  def self.crypt(password, algo = :md5, salt = nil, magic='$1$')
+
+    salt ||= generate_salt(8)
+
+    case algo
+      when :md5
+        require "digest/md5"
+      when :sha1
+        require "digest/sha1"
+      when :rmd160
+        require "digest/rmd160"
+      when :sha256, :sha384, :sha512
+        require "digest/sha2"
+    else
+      raise(ArgumentError, "unknown algorithm")
+    end
+    digest_class = Digest.const_get(algo.to_s.upcase)
+
+    # The password first, since that is what is most unknown. Then our magic string. Then the raw salt.
+    m = digest_class.new
+    m.update(password + magic + salt)
+
+    # Then just as many characters of the MD5(pw,salt,pw)
+    mixin = digest_class.new.update(password + salt + password).digest
+    password.length.times do |i|
+      m.update(mixin[i % 16].chr)
+    end
+
+    # Then something really weird...
+    # Also really broken, as far as I can tell.  -m
+    i = password.length
+    while i != 0
+      if (i & 1) != 0
+        m.update("\x00")
+      else
+        m.update(password[0].chr)
+      end
+      i >>= 1
+    end
+
+    final = m.digest
+
+    # and now, just to make sure things don't run too fast
+    1000.times do |i|
+      m2 = digest_class.new
+
+      if (i & 1) != 0
+        m2.update(password)
+      else
+        m2.update(final)
+      end
+
+      if (i % 3) != 0
+        m2.update(salt)
+      end
+      if (i % 7) != 0
+        m2.update(password)
+      end
+
+      if (i & 1) != 0
+        m2.update(final)
+      else
+        m2.update(password)
+      end
+
+      final = m2.digest
+    end
+
+    # This is the bit that uses to64() in the original code.
+
+    rearranged = ""
+
+    [ [0, 6, 12], [1, 7, 13], [2, 8, 14], [3, 9, 15], [4, 10, 5] ].each do |a, b, c|
+
+      v = final[a] << 16 | final[b] << 8 | final[c]
+
+      4.times do
+        rearranged += ITOA64[v & 0x3f].chr
+        v >>= 6
+      end
+    end
+
+    v = final[11]
+
+    2.times do
+      rearranged += ITOA64[v & 0x3f].chr
+      v >>= 6
+    end
+
+    magic + salt + '$' + rearranged
+  end
+
+
+  # check the validity of a password against an hashed string
+
+  def self.check(password, hash, algo = :md5)
+    magic, salt = hash.split('$')[1,2]
+    magic = '$' + magic + '$'
+    self.crypt(password, algo, salt, magic) == hash
+  end
+
+
+  # generate a +size+ length random salt
+
+  def self.generate_salt(size)
+    (1..size).collect { ITOA64[rand(ITOA64.size)].chr }.join("")
+  end
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin test
+
+  require "test/unit"
+
+  class CryptTest < Test::Unit::TestCase
+
+    def array_test(arr, algo)
+      arr.each do |password, hash|
+        assert(Crypt.check(password, hash, algo))
+      end
+    end
+
+    def test_md5
+      a = [ [' ', '$1$yiiZbNIH$YiCsHZjcTkYd31wkgW8JF.'],
+        ['pass', '$1$YeNsbWdH$wvOF8JdqsoiLix754LTW90'],
+        ['____fifteen____', '$1$s9lUWACI$Kk1jtIVVdmT01p0z3b/hw1'],
+        ['____sixteen_____', '$1$dL3xbVZI$kkgqhCanLdxODGq14g/tW1'],
+        ['____seventeen____', '$1$NaH5na7J$j7y8Iss0hcRbu3kzoJs5V.'],
+        ['__________thirty-three___________', '$1$HO7Q6vzJ$yGwp2wbL5D7eOVzOmxpsy.'],
+        ['apache', '$apr1$J.w5a/..$IW9y6DR0oO/ADuhlMF5/X1']
+      ]
+      array_test(a, :md5)
+    end
+
+    def test_bad_algo
+      assert_raise(ArgumentError) do
+        Crypt.crypt("qsdf", :qsdf)
+      end
+    end
+
+  end
+
+=end
+