alib 0.3.1 → 0.4.0

data/lib/alib-0.4.0/configfile.rb

@@ -0,0 +1,113 @@
+#
+# yaml configfile class
+#
+class ALib::ConfigFile < ::Hash
+#--{{{
+  DEFAULT_CONIFG = {}
+  DEFAULT_SEARCH_PATH = %w(. ~ /usr/local/etc /usr/etc /etc)
+  DEFAULT_BASENAME = ".#{ File::basename $0 }.conf"
+
+  class << self
+#--{{{
+    attr :config, true
+    attr :search_path, true
+    attr :basename, true
+    attr :default_text, true
+    def init
+#--{{{
+      @config = DEFAULT_CONIFG
+      @search_path = DEFAULT_SEARCH_PATH
+      @basename = DEFAULT_BASENAME
+#--}}}
+    end
+    def gen_template port = nil 
+#--{{{
+      port ||= STDOUT
+      buf = @default_text || @config.to_yaml
+      if port.respond_to? 'write' 
+        port.write buf
+        port.write "\n"
+      else
+        open("#{ port }", 'w'){|f| f.puts buf}
+      end
+#--}}}
+    end
+    def default= conf
+#--{{{
+      if conf.respond_to?('read')
+        @default_text = munge conf.read
+        @config = YAML::load @default_text
+      else
+        case conf
+          when Hash
+            @config = conf
+          when Pathname 
+            open(conf) do |f| 
+              @default_text = munge f.read
+              @config = YAML::load @default_text
+            end
+          when String
+            @default_text = munge conf 
+            @config = YAML::load @default_text
+        end
+      end
+      @config
+#--}}}
+    end
+    alias set_default default=
+    def default(*a)
+#--{{{
+      if a.empty?
+        @config ||= {}
+      else
+        self.default= a.first
+      end
+#--}}}
+    end
+    def any(basename = @basename, *dirnames)
+#--{{{
+      config = nil
+      dirnames = @search_path if dirnames.empty?
+      dirnames.each do |dirname|
+        path = File::join dirname, basename 
+        path = File::expand_path path
+        if test ?e, path
+          config = self::new path
+          break
+        end
+      end
+      config || self::new('default') 
+#--}}}
+    end
+    def munge buf
+#--{{{
+      buf.gsub(%r/\t/o,' ')
+#--}}}
+    end
+#--}}}
+  end
+  self.init
+
+  attr :path
+  def initialize path = 'default'
+#--{{{
+    @path = nil 
+    yaml = nil
+    if path.nil? or path and path =~ /^\s*default/io
+      yaml = self.class.default 
+      @path = 'DEFAULT' 
+    else path
+      yaml = YAML::load(self.class.munge(open(path).read))
+      @path = path
+    end
+    self.update yaml
+#--}}}
+  end
+  def to_hash
+#--{{{
+    {}.update self
+#--}}}
+  end
+#--}}}
+end # class ConfigFile
+ALib::Configfile = ALib::ConfigFile

data/lib/alib-0.4.0/find2.rb

@@ -0,0 +1,294 @@
+#                                                         -*- Ruby -*-
+# Copyright (C) 1998, 2001  Motoyuki Kasahara
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+# 
+# 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.  See the
+# GNU General Public License for more details.
+#
+#
+# Traverse a file tree, replacement of `find.rb'.
+#
+class ALib::Find2
+#--{{{
+#
+# Constatnts
+#
+  FIND1 = 1
+  FIND2 = 2
+#
+# Initializer.
+#
+  def initialize(mode = FIND1)
+#--{{{
+    @mode   = mode
+    @depth  = false
+    @follow = false
+    @xdev   = false
+
+    @dirname_stats = Array.new
+    @found_files = Array.new
+    @target_device = 0
+
+    @handle = lambda { |file, stat_result, block|
+      case @mode
+        when FIND1
+          block ? block.call(file) : @found_files.push(file)
+        when FIND2
+          block ? block.call(file, stat_result) : @found_files.push([file, stat_result])
+      end
+    }
+#--}}}
+  end
+#
+# Methods for accessing instances.
+#
+  attr :depth
+  attr :follow
+  attr :xdev
+#
+# Find the directory `dirname'. (private)
+#
+  def find(*arguments, &block)
+#--{{{
+    #
+    # Parse options if specified.
+    #
+    #if arguments[0].type == Hash
+      #parse_options(arguments.shift)
+    #end
+
+# hack
+    args = []
+    opts = []
+    arguments.each do |arg|
+      case arg
+        when Hash
+          opts << arg
+        else
+          args << arg
+      end
+    end
+    opts.each{|opt| parse_options opt}
+    files = args.flatten.compact
+
+    #
+    # If a block is not given to the `find' method, found files are
+    # recorded in this array.
+    #
+    @dirname_stats.clear
+    @found_files.clear
+
+    #
+    # Loop for each file in `files'.
+    #
+    files.each do |file|
+      catch(:prune) do
+      @dirname_stats.clear
+
+      #
+      # Get `stat' or `lstat' of `file'.
+      #
+      begin
+        if @follow
+          begin
+            stat_result = File.stat(file)
+          rescue Errno::ENOENT, Errno::EACCES
+            stat_result = File.lstat(file)
+          end
+        else
+          stat_result = File.lstat(file)
+        end
+      rescue Errno::ENOENT, Errno::EACCES
+        next
+      end
+
+      #
+      # Push `file' to the found stack, or yield with it,
+      # if the depth flag is enabled.
+      #
+      @handle[ file, stat_result, block ] if !@depth
+
+      #
+      # If `file' is a directory, find files recursively.
+      #
+      if stat_result.directory?
+        @xdev_device = stat_result.dev if @xdev
+        @dirname_stats.push(stat_result)
+        find_directory(file, block)
+      end
+
+      #
+      # Push `file' to the found stack, or yield with it.
+      # if the depth flag is disabled.
+      #
+      @handle[ file, stat_result, block ] if @depth
+
+      end
+    end
+
+    if block == nil
+      return @found_files
+    else
+      return nil
+    end
+#--}}}
+  end
+#
+# Find the directory `dirname'. (private)
+#
+  def find_directory(dirname, block)
+#--{{{
+    #
+    # Open the directory `dirname'.
+    #
+    begin
+      dir = Dir.open(dirname)
+    rescue
+      return
+    end
+
+    #
+    # Read all directory entries except for `.' and `..'.
+    #
+    entries = Array.new
+    loop do
+      begin
+      entry = dir.read
+      rescue
+      break
+      end
+      break if entry == nil
+      next if entry == '.' || entry == '..'
+      entries.push(entry)
+    end
+
+    #
+    # Close `dir'.
+    #
+    dir.close
+
+    #
+    # Loop for each entry in this directory.
+    #
+    catch(:prune) do
+      entries.each do |entry|
+      #
+      # Set `entry_path' to the full path of `entry'.
+      #
+      if dirname[-1, 1] == File::Separator
+        entry_path = dirname + entry
+      else
+        entry_path = dirname + File::Separator + entry
+      end
+
+      #
+      # Get `stat' or `lstat' of `entry_path'.
+      #
+      begin
+        if @follow
+          begin
+            stat_result = File.stat(entry_path)
+          rescue Errno::ENOENT, Errno::EACCES
+            stat_result = File.lstat(entry_path)
+          end
+        else
+          stat_result = File.lstat(entry_path)
+        end
+      rescue Errno::ENOENT, Errno::EACCES
+        next
+      end
+
+      #
+      # Push `entry_path' to the found stack, or yield with it,
+      # if the depth flag is enabled.
+      #
+
+      @handle[ entry_path, stat_result, block ] if !@depth
+
+      #
+      # If `entry_path' is a directory, find recursively.
+      #
+      if stat_result.directory? \
+        && (!@xdev || @xdev_device == stat_result.dev) \
+        && (!@follow || !visited?(stat_result))
+        @dirname_stats.push(stat_result)
+        find_directory(entry_path, block)
+        @dirname_stats.pop
+      end
+
+      #
+      # Push `entry_path' to the found stack, or yield with it,
+      # if the depth flag is disabled.
+      #
+      @handle[ entry_path, stat_result, block ] if @depth
+
+      end
+    end
+#--}}}
+  end
+  private :find_directory
+#
+# Find the directory `dirname'. (class method)
+#
+  def self.find(*arguments, &block)
+    new.find(*arguments, &block)
+  end
+#
+# Find the directory `dirname'. (class method)
+#
+  def self.find2(*arguments, &block)
+    new(FIND2).find(*arguments, &block)
+  end
+#
+# Parse options.
+#
+  def parse_options(options)
+#--{{{
+    return if options == nil
+
+    options.each_pair do |key, value|
+      case "#{ key }".strip.downcase
+        when 'depth'
+          @depth = value
+        when 'follow'
+          @follow = value
+        when 'xdev'
+          @xdev = value
+        else
+          raise ArgumentError, "unknown option - #{key}"
+      end
+    end
+#--}}}
+  end
+  private :parse_options
+#
+# Prune the current visited directory.
+#
+  def self.prune
+#--{{{
+    throw :prune
+#--}}}
+  end
+#
+# Did we visit the directory with the resouce `stat'? (private)
+#
+  def visited?(stat_result)
+#--{{{
+    dev = stat_result.dev
+    ino = stat_result.ino
+    @dirname_stats.each do |i|
+      return TRUE if i.dev == dev && i.ino == ino
+    end
+    return FALSE
+#--}}}
+  end
+  private :visited?
+#--}}}
+end # class Find2
+ALib::Find = ALib::Find2

data/lib/alib-0.4.0/listfile.rb

@@ -0,0 +1,42 @@
+#
+# file of lines, comments and blank lines are ignored
+#
+class ALib::ListFile < ::Array
+#--{{{
+  class << self
+#--{{{
+    def parse arg, &b
+#--{{{
+      arg.respond_to?('gets') ? loadio(arg, &b) : open(arg.to_s){|f| loadio(f, &b)}
+#--}}}
+    end
+    def loadio io
+#--{{{
+      while((line = io.gets))
+        line.gsub!(%r/#.*/o,'')
+        next if line =~ %r/^[^\S]+$/o
+        line.gsub!(%r/^[^\S]+|[^\S]+$/o,'')
+        yield line
+      end
+#--}}}
+    end
+#--}}}
+  end
+  attr :path
+  def initialize arg 
+#--{{{
+    case arg
+      when Pathname, String
+        @path = path
+        self.class.parse(arg){|line| self << line}
+      when IO
+        @path = arg.respond_to?('path') ? arg.path : arg.to_s
+        self.class.loadio(arg){|line| self << line}
+      else
+        raise "cannot initialize from <#{ arg.inspect }>"
+    end
+#--}}}
+  end
+#--}}}
+end # class ListFile
+ALib::Listfile = ALib::ListFile