facets 1.0.3 → 1.1.0

data/packages/more/lib/facet/consoleapp.rb

@@ -1,123 +0,0 @@
-#--
-# Console Applicaiton
-#
-# Copyright (c) 2005, 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.
-#
-# =============================================================
-#  HISTORY
-# -------------------------------------------------------------
-#  2005-09-09 Trans  * Created.
-# =============================================================
-#
-# TODO Add documentation features.
-#
-#++
-
-#:title: Console Application
-#
-# Console::Application provides a clean and easy way
-# to create a command line interface for your program.
-# The unique technique utlizes  Commandline to Object
-# Mapping (COM) to make it quick and easy.
-#
-# == Synopsis
-#
-# Given an excutable 'myapp':
-#
-#   #!/usr/bin/env ruby
-#
-#   require 'calibre/consoleapp'
-#
-#   MyApp << Console::Application
-#
-#     def _v
-#       $VERBOSE = true
-#     end
-#
-#     def jump
-#       if $VERBOSE
-#         puts "JUMP! JUMP! JUMP!"
-#       else
-#         puts "Jump"
-#       end
-#     end
-#
-#   end
-#
-#   MyApp.run
-#
-# Then on the command line:
-#
-#   > myapp jump
-#   Jump
-#
-#   > myapp -v jump
-#   JUMP! JUMP! JUMP!
-#
-
-module Console ; end
-
-class Console::Application
-
-  def go
-    i = 0; args = ARGV.dup
-    while i < ARGV.size
-      if md = %r{^[-]}.match( ARGV[i] )
-        opt = ARGV[i].gsub('-','_')
-        if self.respond_to?( opt )
-          m = method( opt )
-          c = m.arity
-          if c > 0
-            m.call(*args[i+1..i+c])
-            args[i..i+c] = nil
-            i += c
-          else
-            m.call
-            args.delete_at(i)
-          end
-        else
-          $stderr << "unknown option #{ARGV[i]}\n"
-          exit -1
-        end
-      end
-      i += 1
-    end
-
-    # non-secondary command type
-    if self.respond_to?(:main)
-      main(*args)
-      exit 0
-    end
-
-    # secondary command type
-    if args.first
-      if self.respond_to?( args.first )
-        __send__( *args )
-      else
-        #begin
-          method_missing( *args )
-        #rescue NoMethodError
-        #  $stderr << "unknown command #{args.join(' ')}\n"
-        #  exit -1
-        #end
-      end
-    elsif self.respond_to?( :default )
-      default(*args)
-    else
-      $stderr << "nothing to do\n"
-      exit -1
-    end
-
-  end #def go
-
-end

data/packages/more/lib/facet/coroutine.rb

@@ -1,172 +0,0 @@
-#--
-# Coroutine
-#
-# Copyright (c) 2005 Florian Frank
-#
-# 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.
-#
-# ==========================================================================
-# Revision History
-# ==========================================================================
-#  2005.04.28  1.0  Trans     * Ported to Calibre.
-# ==========================================================================
-#++
-
-#:title: 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
-#
-# == Author(s)
-#
-# * Florian Frank
-#
-
-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/packages/more/lib/facet/crypt.rb

@@ -1,180 +0,0 @@
-# Crypt(3)
-# Version 0.2.0 2005-09-28
-
-# 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
-
-# This port adds no further stipulations.  I forfeit any copyright interest.
-
-module Crypt
-
-  ITOA64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-
-  # an 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, :sha1, :rmd160
-        require "digest/#{algo}"
-      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
-