gnn-rblibs 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 tarao
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,32 @@
+= gnn-rblibs
+
+Some Ruby tweaks.
+
+== Installation
+
+First, make your gem source gemcutter by
+
+  gem install gemcutter
+  gem tumble
+
+or
+
+  gem sources -a http://gemcutter.org
+
+then
+
+  gem install gnn-rblibs
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 tarao. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "gnn-rblibs"
+    gem.summary = %Q{Some Ruby tweaks}
+    gem.description = %Q{Some Ruby tweaks for file operations, commandline parsers, etc.}
+    gem.email = "tarao.gnn@gmail.com"
+    gem.homepage = "http://github.com/tarao/gnn-rblibs"
+    gem.authors = ["tarao"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "gnn-rblibs #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/gnn-rblibs.gemspec

@@ -0,0 +1,67 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{gnn-rblibs}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["tarao"]
+  s.date = %q{2009-11-28}
+  s.description = %q{Some Ruby tweaks for file operations, commandline parsers, etc.}
+  s.email = %q{tarao.gnn@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "gnn-rblibs.gemspec",
+     "lib/dir/each_leaf.rb",
+     "lib/file/kind.rb",
+     "lib/file/observer.rb",
+     "lib/fileutils/sync.rb",
+     "lib/getopt.rb",
+     "lib/loadconf.rb",
+     "lib/plugin.rb",
+     "lib/process/invoke.rb",
+     "lib/rbconfig/command.rb",
+     "lib/string/random.rb",
+     "lib/term/countdown.rb",
+     "lib/webrick/single_thread_server.rb",
+     "lib/www/mechanize/get.rb",
+     "spec/gnn-rblibs_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/tarao/gnn-rblibs}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Some Ruby tweaks}
+  s.test_files = [
+    "spec/spec_helper.rb",
+     "spec/gnn-rblibs_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/lib/dir/each_leaf.rb

@@ -0,0 +1,17 @@
+class Dir
+  def self.children(path, flag=0)
+    c = self.glob(File.join(path, '*'), flag).reject{|f| f=~/\/\.+$/}
+    return block_given? ? c.each(&Proc.new) : c
+  end
+
+  def self.each_leaf(path, flag=0, nofollow=false, block=nil)
+    block = Proc.new if block_given?
+    if (!nofollow || !File.symlink?(path)) && File.directory?(path)
+      self.children(path, flag) do |child|
+        self.each_leaf(child, flag, nofollow, block) # recursive
+      end
+    else
+      block && block.call(path)
+    end
+  end
+end

data/lib/file/kind.rb

@@ -0,0 +1,8 @@
+class File
+  def self.kind(file, nofollow=false)
+    k = [ :directory, :file ]
+    k.unshift(:symlink) if nofollow
+    return k.find{|w| self.send(w.to_s+'?', file)}
+  end
+end
+

data/lib/file/observer.rb

@@ -0,0 +1,138 @@
+class File
+  class Observer
+    ACCESS = 0x0001
+    MODIFY = 0x0002
+    ATTRIB = 0x0004
+#     CLOSE_WRITE   = 0x0008
+#     CLOSE_NOWRITE = 0x0010
+#     OPEN          = 0x0020
+    MOVED_FROM = 0x0040
+    MOVED_TO   = 0x0080
+    CREATE = 0x0100
+    DELETE = 0x0200
+#     DELETE_SELF = 0x0400
+#     MOVE_SELF   = 0x0800
+#     CLOSE = CLOSE_WRITE | CLOSE_NOWRITE
+    MOVE = MOVED_FROM | MOVED_TO
+    CHANGE = MODIFY | ATTRIB | MOVE | CREATE | DELETE
+
+    class Win32
+      def self.installed?
+        begin
+          require 'rubygems'
+          require 'win32/changenotify'
+        rescue LoadError
+          return false
+        end
+        return self
+      end
+
+      def self.watch(files, events, dir = false)
+        mask = 0
+        # FIXME: more events
+#        mask |= ::Win32::ChangeNotify::ATTRIBUTES if (events & ATTRIB) != 0
+        mask |= ::Win32::ChangeNotify::DIR_NAME   if (events & MOVE) != 0
+        mask |= ::Win32::ChangeNotify::FILE_NAME  if (events & MOVE) != 0
+        mask |= ::Win32::ChangeNotify::LAST_WRITE if (events & CHANGE) != 0
+        mask |= ::Win32::ChangeNotify::SIZE       if (events & CHANGE) != 0
+        directory = dir ? files : File.dirname(files.first)
+        cn = ::Win32::ChangeNotify.new(directory, false, mask)
+        loop do
+          cn.wait do |arr|
+            arr.each do |st|
+              if dir || files.find{|f| f == st.file_name}
+                # FIXME: convert st.action to event
+                yield({ :name => st.file_name,
+                        :event => events,
+                        :class => self })
+                return true
+              end
+            end
+          end
+        end
+        return false
+      end
+
+      def self.watch_dir(dir, events, &block)
+        return self.watch(dir, events, true, &block)
+      end
+    end
+
+    class Inotify
+      def self.installed?
+        begin
+          require 'inotify'
+        rescue LoadError
+          return false
+        end
+        return self
+      end
+
+      def self.watch(files, events)
+        notifier = ::Inotify.new
+        begin
+          files.each{|f| notifier.add_watch(f, events)}
+          notifier.each_event do |e|
+            yield({ :event => e.mask,
+                    :class => self })
+            return true
+          end
+        ensure
+          notifier.close
+        end
+        return false
+      end
+
+      def self.watch_dir(dir, events, &block)
+        return self.watch(dir, events, &block)
+      end
+    end
+
+    class Naive
+      def self.installed?
+        return Naive
+      end
+
+      def self.watch(files, events, s=0.1)
+        mtime = {}
+        files.each{|f| mtime[f] = File.mtime(f)}
+
+        loop do
+          # FIXME: other events
+          fname = files.find{|f| File.mtime(f) != mtime[f]}
+          if fname
+            yield({ :name => fname,
+                    :event => events,
+                    :class => self })
+            return true
+          end
+          sleep(s)
+        end
+        return false
+      end
+
+      def self.watch_dir(dir, events, s=0.1, &block)
+        return self.watch(dir, events, s, &block)
+      end
+    end
+
+    def self.watch(files, events, &block)
+      klass = Win32.installed? || Inotify.installed? || Naive.installed?
+      raise 'No file observer' unless klass
+      files = [files] unless files.is_a?(Array)
+      mtime = {}
+      files.each{|f| mtime[f] = File.mtime(f)}
+      return klass.watch(files, events) do |x|
+        # FIXME: other events
+        x[:name] = x[:name] || files.find{|f| File.mtime(f) != mtime[f]}
+        block.call(x)
+      end
+    end
+
+    def self.watch_dir(dir, events, &block)
+      klass = Win32.installed? || Inotify.installed? || Naive.installed?
+      raise 'No file observer' unless klass
+      return klass.watch_dir(dir, events, &block)
+    end
+  end
+end

data/lib/fileutils/sync.rb

@@ -0,0 +1,61 @@
+require 'file/kind'
+require 'dir/each_leaf'
+require 'fileutils'
+
+module FileUtils
+  class Sync
+    def self.each_leaf(src, dst, flag=0, nf=false, block=nil)
+      block = Proc.new if block_given?
+      if [File.kind(src, nf), File.kind(dst, nf)].all?{|k| k == :directory}
+        Dir.children(src, flag) do |file|
+          target = File.join(dst, File.basename(file))
+          self.each_leaf(file, target, flag, nf, block) # recursive
+        end
+      else
+        block && block.call(src, dst)
+      end
+    end
+
+    def self.conflict?(src, dst, nofollow=false)
+      return false unless File.exist?(dst)
+      return File.kind(src, nofollow) != File.kind(dst, nofollow)
+    end
+
+    def self.uptodate?(s, d)
+      cond = false
+      cond ||= !File.exist?(d)
+      cond ||= File.file?(s) && File.file?(d) && FileUtils.uptodate?(s, d)
+      return cond
+    end
+
+    def initialize(opt={})
+      @cond = opt[:cond] || {}
+      @cond[:conflict] ||= proc{|s,d| self.class.conflict?(s,d)}
+      @cond[:uptodate] ||= proc{|s,d| self.class.uptodate?(s,d)}
+
+      @method = opt[:method] || {}
+      @method[:conflict] ||= proc{}
+      @method[:uptodate] ||= proc do |s, d|
+        FileUtils.cp_r(s, d, {:preserve => true})
+      end
+      @method[:nothing] ||= proc{}
+
+      @flag = opt[:flag] || 0
+      @nofollow = opt[:nofollow] || false
+    end
+
+    def sync(src, dst)
+      self.class.each_leaf(src, dst, @flag, @nofollow) do |s,d|
+        none = proc{ :nothing }
+        what = [ :conflict, :uptodate ].find(none){|w| @cond[w].call(s, d)}
+        @method[what].call(s, d)
+      end
+    end
+  end
+
+  def sync(src, dst, opt={})
+    Sync.new(opt).sync(src, dst)
+  end
+
+  module_function :sync
+end

data/lib/getopt.rb

@@ -0,0 +1,185 @@
+class GetOpt
+  def self.escape(str, quote=true)
+    str = str.to_s
+    return str unless str.match(/[\\\"\'\s]/)
+    str = str.gsub(/\\/, '\\\\').gsub(/\"/, '\\\"')
+    return quote ? '"'+str+'"' : str
+  end
+
+  attr_accessor :args, :parsed, :rest, :parser
+
+  def initialize(args, *opts)
+    @parsed = {}
+    @args = []
+    @rest = []
+
+    # argument syntax definitions
+    syntax(opts[0] || [], opts[1] || {})
+
+    # custom parser
+    @parser = {
+      :custom => (opts[1].is_a?(Proc) && opts[1]) || proc{|v| eat(v)}
+    }
+
+    pparse_rest       = proc{|n,v,a,r| parse_rest(n,v,a,r)}
+    pparse_val        = proc{|n,v,a,r| parse_val(n,v,a,r)}
+    pparse_bool_short = proc{|n,v,a,r| parse_bool_short(n,v,a,r)}
+    pparse_bool_long  = proc{|n,v,a,r| parse_bool_long(n,v,a,r)}
+
+    # parser for short arguments
+    @parser[:short] = {
+      'b' => pparse_bool_short,
+      'i' => pparse_val,
+      'f' => pparse_val,
+      's' => pparse_val,
+    }
+
+    # parser for long arguments
+    @parser[:long] = {
+      'b' => pparse_bool_long,
+      'i' => pparse_val,
+      'f' => pparse_val,
+      's' => pparse_val,
+      ''  => pparse_rest, # '... -- ...' is a separator
+    }
+
+    return parse(args || [])
+  end
+
+  def syntax(opts, default={})
+    @full = {}
+    @type = {}
+    @default = {}
+    default.each{|k,v| @default[k.to_s] = v}
+    opts.each do |opt|
+      default_value = nil
+      if opt.is_a?(Array)
+        default_value = opt[1]
+        opt = opt[0]
+      end
+      if opt =~ /^(?:([^-=])\|)?([^-=]+)(?:=(.+))?$/
+        @type[$2] = $3 || 'b'
+        @full[$1] = $2 if $1
+        @default[$2.to_s] = default_value if default_value
+      end
+    end
+    @type[''] = ''
+    return self
+  end
+
+  def parse(args)
+    args = @parser[:custom].call(args) while args.length != 0
+    return self
+  end
+
+  def [](opt)
+    opt = opt.to_s
+    val = @parsed[opt]
+    return val == nil ? @default[opt] : val
+  end
+
+  def []=(opt,val)
+    return @parsed[opt.to_s] = val
+  end
+
+  def push(name, val)
+    if @type[name] == 'b'
+      if !val
+        @parsed[name] = false
+      elsif !@parsed[name]
+        @parsed[name] = true
+      elsif @parsed[name].is_a?(Integer)
+        @parsed[name] = @parsed[name].succ
+      else # @parsed[name] == true
+        @parsed[name] = 2 # promote to be an Integer
+      end
+    else
+      if @parsed[name].instance_of?(Array)
+        @parsed[name] << val
+      elsif @parsed[name]
+        @parsed[name] = [ @parsed[name], val ] # promote to be an Array
+      else
+        @parsed[name] = val
+      end
+    end
+    return self
+  end
+
+  def to_s
+    arr1 = []
+    @parsed.each{|name,value|
+      if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        arr1 << ('--' + (value ? '' : 'no-') + name)
+      elsif @type[name] == 'b' && value.is_a?(Integer)
+        arr1 += (1..value).map{|v| '--' + name}
+      elsif value.is_a?(Array)
+        value.each{|v| arr1 << ('--' + name + '=' + self.class.escape(v))}
+      else
+        arr1 << ('--' + name + '=' + self.class.escape(value))
+      end
+    }
+    arr2 = @args
+    arr2 += ['--'] + @rest if @rest.length > 0
+    return (arr1 + arr2.map{|val| self.class.escape(val)}).join(' ')
+  end
+
+  # predefined parsers
+
+  def parse_bool_short(name, val, arg, rest)
+    flags = arg[1..-1] # skip '-'
+    flags.each_byte do |f| # for each flag
+      name = @full[f.chr]
+      if name && @type[name] == 'b'
+        push(name, true)
+      else
+        parse_unknown(name, nil, '-'+f.chr, rest)
+      end
+    end
+    return rest
+  end
+
+  def parse_bool_long(name, val, arg, rest)
+    push(name, !( (val == 'false') ^ (arg =~ /^--no/) ))
+    return rest
+  end
+
+  def parse_val(name, val, arg, rest)
+    val = (val || rest.shift).send('to_' + @type[name]) # to_i, to_f, etc.
+    push(name, val)
+    return rest
+  end
+
+  def parse_rest(name, val, arg, rest)
+    @rest = rest
+    return []
+  end
+
+  def parse_unknown(name, val, arg, rest)
+    @args << arg
+    return rest
+  end
+
+  private
+
+  def get_parser(name, long)
+    parser = @parser[ long ? :long : :short ]
+    return parser[@type[name]] || proc{|n,v,a,r| parse_unknown(n,v,a,r)}
+  end
+
+  def eat(args)
+    arg = args.shift
+
+    long = false
+    name = nil
+    if arg =~ /^--(no-?)?([^=]*)(?:=(.*))?$/
+      long = true
+      name = (@type[$2] || !$1) ? $2 : $1+$2
+      val = $3
+    elsif arg =~ /^-([^-])(.+)?$/
+      name = @full[$1]
+      val = $2
+    end
+
+    return get_parser(name, long).call(name, val, arg, args)
+  end
+end

data/lib/loadconf.rb

@@ -0,0 +1,26 @@
+module LoadConf
+  def report(method, e)
+    if method.instance_of?(String)
+      warn(method)
+    elsif method.instance_of?(Proc)
+      method.call(e)
+    end
+  end
+
+  def load(fname, *opt)
+    er = opt[0] || {}
+    begin
+      open(fname) do |src|
+        begin
+          return instance_eval(src.read.untaint, fname, 1)
+        rescue => e
+          report(er[:script], e)
+        end
+      end
+    rescue SystemCallError => e
+      report(er[:open], e)
+    end
+  end
+
+  module_function :load, :report
+end

data/lib/plugin.rb

@@ -0,0 +1,28 @@
+class Plugin
+  @@list = []
+  def self.load(dir)
+    Dir::glob("#{dir}/*.rb").each do |fname|
+      open(fname) do |src|
+        begin
+          val = instance_eval(src.read.untaint, fname, 1)
+          @@list << val if val
+          warn("loaded plugin: #{fname}")
+        rescue
+          warn($!)
+        end
+      end
+    end
+  end
+
+  attr_reader :api
+  def initialize(args)
+    @api = []
+    @@list.each do |klass|
+      begin
+        @api += klass.new(*args).api
+      rescue
+        warn($!)
+      end
+    end
+  end
+end

data/lib/process/invoke.rb

@@ -0,0 +1,15 @@
+module Process
+  def invoke(cmd)
+    begin
+      require 'rubygems'
+      require 'win32/process'
+      args = {
+        'command_line' => cmd,
+      }
+      Process.create(args)
+    rescue LoadError
+      system(cmd + ' &')
+    end
+  end
+  module_function :invoke
+end

data/lib/rbconfig/command.rb

@@ -0,0 +1,22 @@
+require 'rbconfig'
+
+module RbConfig
+  cmd = File.join(CONFIG['bindir'], CONFIG['ruby_install_name'])
+  CONFIG['ruby_command'] = cmd.sub(/.*\s.*/m, '"\&"')
+
+  def program_name
+    return (defined?(ExerbRuntime) && ExerbRuntime.filepath) || $0
+  end
+
+  def self_invoke_command
+    cmd = File.expand_path(program_name)
+    cmd.sub(/.*\s.*/m, '"\&"')
+    ext = Config::CONFIG['EXEEXT']
+    unless ext.length != 0 && program_name =~ /#{ext}$/
+      cmd = CONFIG['ruby_command'] + ' ' + cmd
+    end
+    return cmd
+  end
+
+  module_function :program_name, :self_invoke_command
+end

data/lib/string/random.rb

@@ -0,0 +1,15 @@
+class String
+  def randomize(len=128)
+    return Array.new(len).map{ self[rand(self.length)].chr }.join
+  end
+
+  def self.random(len=128, src=nil)
+    src ||=
+      [
+       'a'..'z',
+       'A'..'Z',
+       0..9,
+      ].map{|v| v.to_a}.join + '!@#$%^&*()_-=,./'
+    return src.randomize(len)
+  end
+end

data/lib/term/countdown.rb

@@ -0,0 +1,50 @@
+require 'termios'
+
+module Term
+  def countdown(time, *args, &block)
+    wait, br = args
+    if args[0].instance_of?(Hash)
+      wait = args[0][:wait]
+      br = args[0][:br]
+    end
+    wait ||= 0.05
+    br ||= '[\r\n]'
+    default = proc do |elapse|
+      t = time - elapse
+      t = 0 if t < 0
+      t *= 1000
+      $stdout.flush
+      printf("\r%6d", t.to_i)
+    end
+    block = default unless block
+
+    old = Termios.tcgetattr($stdin)
+    tio = Termios.tcgetattr($stdin)
+    tio.cc[Termios::VMIN] = 1
+    tio.cc[Termios::VTIME] = 0
+    tio.iflag &= ~Termios::ICRNL  # see libcurses/screen/cbreak.c
+    tio.lflag &= ~Termios::ICANON
+    tio.lflag &= ~Termios::ECHO
+    Termios.tcsetattr($stdin, Termios::TCSANOW, tio)
+
+    begin
+      s = Time.now.to_f
+      e = s + time.to_f
+      while true
+        now = Time.now.to_f
+        block.call(now - s)
+        break if now >= e
+        sleep(wait)
+        s = $stdin.read_nonblock(1) rescue next
+        break if s =~ /#{br}/
+          return false
+      end
+    ensure
+      Termios.tcsetattr($stdin, Termios::TCSANOW, old)
+    end
+
+    return true
+  end
+
+  module_function :countdown
+end

data/lib/webrick/single_thread_server.rb

@@ -0,0 +1,80 @@
+require 'thread'
+require 'socket'
+require 'timeout'
+require 'webrick/config'
+require 'webrick/log'
+
+module WEBrick
+  class GenericServer
+    def start(&block)
+      raise ServerError, "already started." if @status != :Stop
+      server_type = @config[:ServerType] || SimpleServer
+
+      server_type.start{
+        @logger.info \
+          "#{self.class}#start: pid=#{$$} port=#{@config[:Port]}"
+        call_callback(:StartCallback)
+
+        @status = :Running
+        while @status == :Running
+          begin
+            if svrs = IO.select(@listeners, nil, nil, 2.0)
+              svrs[0].each{|svr|
+                @tokens.pop          # blocks while no token is there.
+                if sock = accept_client(svr)
+                  th = start_thread(sock, &block)
+                else
+                  @tokens.push(nil)
+                end
+              }
+            end
+          rescue Errno::EBADF, IOError => ex
+            # if the listening socket was closed in GenericServer#shutdown,
+            # IO::select raise it.
+          rescue Exception => ex
+            msg = "#{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
+            @logger.error msg
+          end
+        end
+
+        @logger.info "going to shutdown ..."
+        call_callback(:StopCallback)
+        @logger.info "#{self.class}#start done."
+        @status = :Stop
+      }
+    end
+
+    private
+
+    def start_thread(sock, &block)
+      begin
+        Thread.current[:WEBrickSocket] = sock
+        begin
+          addr = sock.peeraddr
+          @logger.debug "accept: #{addr[3]}:#{addr[1]}"
+        rescue SocketError
+          @logger.debug "accept: <address unknown>"
+          raise
+        end
+        call_callback(:AcceptCallback, sock)
+        block ? block.call(sock) : run(sock)
+      rescue Errno::ENOTCONN
+        @logger.debug "Errno::ENOTCONN raised"
+      rescue ServerError => ex
+        msg = "#{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
+        @logger.error msg
+      rescue Exception => ex
+        @logger.error ex
+      ensure
+        @tokens.push(nil)
+        Thread.current[:WEBrickSocket] = nil
+        if addr
+          @logger.debug "close: #{addr[3]}:#{addr[1]}"
+        else
+          @logger.debug "close: <address unknown>"
+        end
+        sock.close
+      end
+    end
+  end    # end of GenericServer
+end

data/lib/www/mechanize/get.rb

@@ -0,0 +1,125 @@
+require 'rubygems'
+require 'mechanize'
+require 'logger'
+
+module WWW
+  class Mechanize
+    class Method
+      attr_accessor :method, :domain, :verbose, :agent, :req
+
+      def initialize(method, conf={}, verbose=nil)
+        @method = method
+        @domain = @method[:type] + '://' + @method[:domain]
+        @verbose = verbose
+
+        # user agent
+        logger = conf[:logger] || (conf[:log] && Logger.new(conf[:log]))
+        @agent = WWW::Mechanize.new{|a| a.log = logger if logger}
+        @agent.ca_file = conf[:ssl_cert] || '/usr/share/ssl/cert.pem'
+        @agent.user_agent_alias = conf[:ua_alias] if conf[:ua_alias]
+        @agent.user_agent = conf[:ua] if conf[:ua]
+        auth = @method[:auth]
+        @agent.auth(auth[:user], auth[:pass]) if auth
+
+        # request methods
+        psend = proc{|rq,r| do_send(rq,r)}
+        @req = {
+          :get    => psend,
+          :post   => psend,
+          :form   => proc{|rq,r| do_form(rq,r)},
+          :regexp => proc{|rq,r| do_parse(rq,r)},
+        }
+
+        return self
+      end
+
+      def do
+        warn("#{@method[:name]}: retrieve by #{@method[:type]}") if @verbose
+        result = { :obj => {} }
+
+        @method[:requests].each do |req|
+          begin
+            if req.is_a?(String)
+              result = @req[:get].call(req, result)
+            elsif req.is_a?(Proc)
+              result = req.call(self, req, result)
+            elsif req.is_a?(Hash)
+              key = @req.keys.find{|k| req.key?(k)}
+              raise 'invalid method' unless key
+              result = @req[key].call(req, result)
+            else
+              raise 'unknown method'
+            end
+          rescue => e
+            warn("#{e}: #{req.to_s}") if @verbose
+          end
+        end
+
+        return result
+      end
+
+      def do_send(req, result) # POST / GET
+        m = (req.is_a?(Hash) && req[:post]) ? :post : :get
+        uri = @domain + (req.is_a?(Hash) ? req[m] : req)
+        params = req.is_a?(Hash) ? req[:params] : {}
+        warn("#{m} #{uri}") if @verbose
+        result[:page] = @agent.send(m.to_s, uri, params || {}) # reflective
+        return result
+      end
+
+      def do_form(req, result) # form.submit
+        raise 'no page at WWW.Mechanize.Method.do_form' unless result[:page]
+
+        name = req[:form]
+        f = result[:page].forms.find{|v| v.name == name} if name.is_a?(String)
+        f = result[:page].forms[name] if name.is_a?(Integer)
+        raise 'failed at WWW.Mechanize.Method.do_form' unless f
+
+        f.action = req[:action] if req[:action]
+        f.set_fields(req[:fields])
+        warn("submit #{f.action}") if @verbose
+        result[:page] = f.submit
+        return result
+      end
+
+      def do_parse(req, result) # parse
+        raise 'no page at WWW.Mechanize.Method.do_parse' unless result[:page]
+
+        if result[:page].body =~ /#{req[:regexp]}/im
+          warn("parse #{req[:regexp]}") if @verbose
+          if req[:result].is_a?(Hash)
+            req[:result].each do |key, val|
+              result[:obj][key] = $~[val]
+            end
+          elsif req[:result].is_a?(String)
+            $~.shift if $~.size > 1
+            result[:obj][req[:result].to_sym] = $~
+          else
+            $~.shift if $~.size > 1
+            result[:obj] = $~
+          end
+        else
+          raise 'parse failed at WWW.Mechanize.Method.do_parse'
+        end
+
+        return result
+      end
+    end
+
+    def self.get(methods, opt)
+      v = opt[:verbose]
+      r = opt[:require]
+      c = opt[:config]
+
+      result = { :obj => {} }
+      methods = [ methods ] unless methods.is_a?(Array)
+      methods.each do |val|
+        m = Method.new(val, c, v)
+        result = m.do
+        break if r.all?{|k| result[:obj][k]}
+      end
+
+      return result
+    end
+  end
+end

data/spec/gnn-rblibs_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "GnnRblibs" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: gnn-rblibs
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- tarao
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-28 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+description: Some Ruby tweaks for file operations, commandline parsers, etc.
+email: tarao.gnn@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- gnn-rblibs.gemspec
+- lib/dir/each_leaf.rb
+- lib/file/kind.rb
+- lib/file/observer.rb
+- lib/fileutils/sync.rb
+- lib/getopt.rb
+- lib/loadconf.rb
+- lib/plugin.rb
+- lib/process/invoke.rb
+- lib/rbconfig/command.rb
+- lib/string/random.rb
+- lib/term/countdown.rb
+- lib/webrick/single_thread_server.rb
+- lib/www/mechanize/get.rb
+- spec/gnn-rblibs_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/tarao/gnn-rblibs
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Some Ruby tweaks
+test_files: 
+- spec/spec_helper.rb
+- spec/gnn-rblibs_spec.rb