dbi-dbrc 1.0.0

data/CHANGES

@@ -0,0 +1,82 @@
+== 1.0.0 - 15-Jun-2005
+* Ditches the use of 'etc'.  Now requires the 'sys-admin' package as its
+  replacement (for all platforms).
+* Moved project to RubyForge.
+* Minor updates to tests, README and gemspec.
+* Now hosted on RubyForge.
+
+== 0.5.1 - 17-Mar-2005
+* Removed the 'doc' directory completely, and moved the primary
+  documentation into the README file.
+* Removed the INSTALL file.  Moved the installation directions into the
+  README file.
+* Moved the examples into a toplevel 'examples' directory.
+* Made the README and CHANGES files rdoc friendly.
+* Added a gemspec.
+
+== 0.5.0 - 15-Oct-2004
+* Added a YAML subclass.  Use this if you want to store your information in
+  the .dbrc file in YAML format.
+* On Win32 systems, the .dbrc file must now be "hidden".  Also, it will
+  automatically decrypt/encrypt the file if it is encrypted.  This also
+  means that the win32-file package is also required on Win32 systems.
+* Massive refactoring of the XML subclass.  It should work better now.
+* Moved the YML and XML subclasses directly into the dbrc.rb file.
+* For the aliases, you can now write as well as read.
+* In lieu of the namespace fix for "timeout" in 1.8, I have renamed "time_out"
+  to simply "timeout".  For backwards compatability, I have created an alias,
+  so you may still use the old method name.  However, this means that you
+  should only use this package with 1.8.0 or later.
+* Removed the dbrc.html file.  You can generate this on your own if you wish
+  using rdtool.
+* Test suite changes.
+
+== 0.4.0 - 3-Sep-2004
+* Removed redundant error handling for cases when the database and/or login
+  are not found.
+* Added an XML subclass.  Use this if you want to store your information in
+  the .dbrc file in XML format.
+
+== 0.3.0 - 26-Oct-2003
+* Win32 support added.  Requires the win32-etc package.
+* rd doc separated from source.  Moved to 'doc' directory.
+* Documentation updates and corrections.
+* Minor test suite tweaks for Win32 systems.
+
+== 0.2.1 - 28-Aug-2003
+* Removed VERSION class method.  Just use the constant.
+* Bug fix with regards to split and Ruby 1.8.  Thanks Michael Garriss.
+* Changed 'changelog' to 'CHANGES'.
+* Added a vanilla test script (test.rb)
+* Minor code optimization (IO.foreach)
+* Test unit cleanup
+* Minor internal directory layout and doc changes
+
+== 0.2.0 - 13-Jan-2003
+* DBRC class now under the DBI module namespace
+* Changed "timeout" to "time_out" to avoid confusion with the timeout
+  module.
+* The 'time_out', 'max_reconn', and 'interval' methods now return Integers,
+  rather than Strings.
+* Only the database, user and password fields are required now within the
+  .dbrc file.  The driver, time_out and max_reconn entries can be left blank
+  without causing an error.  Note that the 'dsn' method will return 'nil'
+  if the driver isn't set.
+* Added a DBRCException class instead of just raising an error string.
+* Changed 'db' method to 'database' (but 'db' is an alias)
+* Changed 'max_reconn' method to 'maximum_reconnects' (but 'max_reconn'
+  is an alias')
+* Added 'passwd' alias for 'password' method 
+* Added a VERSION class method
+* Methods that should have been private are now private
+* Internal directory layout change
+* Tests added
+* Install script improved
+* Documentation additions, including plain text doc
+
+== 0.1.1 - 26-Jul-2002
+* Added 'dsn()' method
+* Minor documentation additions
+
+== 0.1.0 - 26-Jul-2002
+* Initial release

data/README

@@ -0,0 +1,244 @@
+== Description
+   This is a supplement to the dbi module, allowing you to avoid hard-coding
+   passwords in your programs that make database connections.
+
+== Synopsis
+   require 'dbi/dbrc'
+   include DBI
+
+   dbrc = DBRC.new("mydb")
+
+   or
+
+   dbrc = DBRC.new("mydb","someUser")
+
+   puts dbrc.db
+   puts dbrc.user
+   puts dbrc.driver
+   puts dbrc.timeout
+   puts dbrc.max_reconn
+   puts dbrc.interval
+   puts dbrc.dsn
+
+   dbh = DBI.connect(dbrc.dsn, dbrc.user, dbrc.password)
+
+== Requirements
+   * Ruby 1.8.0 or later
+   * sys-admin
+   * win32-file (Win32 only)
+
+== Installation
+=== Manual Installation
+   * ruby test/ts_all.rb (optional)
+   * ruby install.rb
+=== Gem Installation
+   * ruby dbi-dbrc.gemspec
+   * gem install dbi-dbrc-<version>.gem
+   
+== Notes on the .dbrc file
+   This module relies on a file in your home directory called ".dbrc", and it
+   is meant to be analogous to the ".netrc" file used by programs such as
+   telnet. The .dbrc file has several conditions that must be met by the
+   module or it will fail:
+
+   * Permissions must be set to 600 (Unix only).
+   * Must be hidden (Win32 only).
+   * Must be owned by the current user.
+   * Must have database, user and password.  Other fields are optional.
+   * Must be in the following space-separated format (in the 'plain' version):
+
+   database user password driver timeout maximum_reconnects interval
+
+   e.g. mydb     dan    mypass     oracle   10        2         30
+
+   You may include comments in the .dbrc file by starting the line with a
+   "#" symbol
+
+   A failure in any of the rules mentioned above will result in a DBRCError
+   being raised. In addition, the file may also be encrypted on Win32 systems,
+   in which case the file will automatically be (temporarily) decrypted.
+
+   The format for XML (using the example above) is as follows:
+
+   <dbrc>
+      <database name="mydb">
+         <user>dan</user>
+         <password>mypass</password>
+         <driver>oracle</driver>
+         <interval>30</interval>
+         <timeout>10</timeout>
+         <maximum_reconnects>2</maximum_reconnects>
+      </database>
+   </dbrc>
+
+   The format for YAML is as follows:
+
+   - mydb:
+      user: dan
+      password: mypass
+      driver: oracle
+      interval: 30
+      timeout: 10
+      max_reconn: 2
+   
+== Constants
+VERSION
+   The current version of this packages, returned as a String.
+    
+== Class Methods
+DBRC.new(db, user=nil, dir=nil)
+   The constructor takes one to three arguments.  The first argument is the
+   database name.  This *must* be provided.  If only the database name is
+   passed, the module will look for the first database entry in the .dbrc
+   file that matches.
+
+   The second argument, a user name, is optional.  If it is passed, the
+   module will look for the first entry in the .dbrc file where both the
+   database *and* user name match.
+
+   The third argument, also optional, specifies the directory where DBRC will
+   look for the .dbrc file.  By default, it looks in the pwuid (present
+   working user id) home directory.  The rules for a .dbrc file still apply.
+    
+   Win32 users should read the "Notes" section for how your home directory
+   is determined.
+    
+== Instance Methods
+DBRC#database
+   The name of the database.  Note that the same entry can appear more than
+   once, presumably because you have multiple user id's for the same
+   database.
+    
+DBRC#db
+   An alias for DBRC#database.
+    
+DBRC#database=(database)
+   Sets the database to +database+.  This is generally discouraged because
+   it does not automatically reset the dsn.
+    
+DBRC#db=(database)
+   An alias for DBRC#database=.
+   
+DBRC#user
+   A valid user name for that database.
+    
+DBRC#user=(user)
+   Sets the user name to +user+.
+    
+DBRC#password
+   The password for that user.
+    
+DBRC#passwd
+   An alias for DBRC#password.
+    
+DBRC#password=(password)
+   Sets the password to +password+.
+
+DBRC#passwd=(password)
+   An alias for DBRC#password=.
+    
+DBRC#driver
+   The driver type for that database (Oracle, MySql, etc).
+    
+DBRC#driver=(driver)
+   Sets the driver to +driver+.  This use is discouraged because it does
+   not reset the dsn.
+    
+DBRC#timeout
+   The timeout period for a connection before the attempt is dropped.
+   
+DBRC#time_out
+   An alias for DBRC#timeout, provided purely for the sake of backwards
+   compatability.
+    
+DBRC#timeout=(int)
+   Sets the timeout value to +int+.
+   
+DBRC#maximum_reconnects
+   The maximum number of reconnect attempts that should be made for the the
+   database.  Presumablly, you would use this with a "retry" within a rescue
+   block.
+
+DBRC#max_reconn
+   An alias for DBRC#maximum_reconnects.
+   
+DBRC#maximum_reconnects=(max)
+   Sets the maximum number of reconnect attempts to +max+.
+
+DBRC#max_reconn=(max)
+   An alias for DBRC#maximum_reconnects.
+    
+DBRC#interval
+   The number of seconds to wait before attempting to reconnect to the database
+   again should a network/database glitch occur.
+    
+DBRC#interval=(int)
+   Sets the interval seconds between connection attempts.
+    
+DBRC#dsn
+   Returns a string in "dbi:<driver>:<database>" format.
+    
+DBRC#dsn=(dsn)
+   Sets the dsn string to +dsn+.  This method is discouraged because it does
+   not automatically reset the driver or database.
+    
+== Canonical Example
+   This is a basic template for how I do things:
+
+   require "dbi/dbrc"
+   require "timeout"
+
+   db = DBI::DBRC.new("somedb")
+   n = db.max_reconn
+
+   begin
+      timeout(db.time_out){
+         DBI.connect(db.dsn,db.user,db.passwd)
+      }
+   rescue DBI::Error
+      n -= 1
+      sleep db.interval if n > 0
+      retry if n > 0
+      raise
+   rescue TimeoutError
+      # handle timeout error
+   end
+   
+== Notes for Win32 Users
+   The 'home' directory for Win32 users is determined by ENV['USERPROFILE'].
+   If that is not set, ENV['HOME'] is used.  If that is not set, then
+   'C:\Documents and Settings\' + Admin.get_user(Admin.get_login).home_dir is
+   used.
+
+   To make your file hidden, right click on the .dbrc file in your Explorer
+   window, select "Properties" and check the "Hidden" checkbox.
+
+   I was going to require that the .dbrc file be encrypted on Win32 systems,
+   but that may require an official "certificate", assigned to you by a third
+   party, which is a bit much to expect.  However, if the file is encrypted,
+   DBRC will attempt to decrypt it, parse it, and encrypt it again when done
+   parsing.
+   
+== Summary
+   These "methods" don't really do anything.  They're simply meant as a
+   convenience mechanism for you dbi connections, plus a little bit of
+   obfuscation (for passwords).
+
+== Adding your own configuration
+   If you want to add your own type of configuration file, you can still use
+   the dbi-dbrc package.  All you need to do is:
+
+   * subclass DBRC
+   * redefine the +parse_dbrc_config_file+ method
+
+   Take a look at the XML and YML subclasses in dbrc.rb for two examples that
+   you can work from.
+   
+== Known Bugs
+   I'm not positive about the dsn strings for databases other than Oracle.
+   If it's not correct, please let me know.
+   
+== Author
+   Daniel J. Berger
+   djberg96 at gmail dot com
+   imperator on IRC (irc.freenode.net)

data/examples/plain/test.rb

@@ -0,0 +1,21 @@
+###########################################################################
+# test.rb
+#
+# This script is provided for those without TestUnit installed and/or for
+# general futzing.
+###########################################################################
+if File.basename(Dir.pwd) == "plain"
+   Dir.chdir "../.."
+   $LOAD_PATH.unshift Dir.pwd + "/lib"
+   Dir.chdir "examples/plain"
+end
+
+require "pp"
+require "dbi/dbrc"
+include DBI
+
+puts "VERSION: " + DBRC::VERSION
+
+db = DBRC.new("foo","user1",Dir.pwd)
+
+pp db

data/examples/xml/test_xml.rb

@@ -0,0 +1,28 @@
+#######################################################################
+# test_xml.rb
+#
+# Simple test script that uses the DBRC::XML subclass.
+#######################################################################
+if File.basename(Dir.pwd) == "xml"
+   Dir.chdir "../.."
+   $LOAD_PATH.unshift Dir.pwd + "/lib"
+   Dir.chdir "examples/xml"
+end
+
+require "dbi/dbrc"
+require "pp"
+include DBI
+
+puts "VERSION: " + DBRC::XML::VERSION
+
+# Use the .dbrc file in this directory
+db1 = DBRC::XML.new("foo",nil,Dir.pwd) # Get first entry found for 'foo'
+db2 = DBRC::XML.new("foo","user1",Dir.pwd) # Specify user
+
+puts "First entry found for 'foo': "
+pp db1
+puts "=" * 20
+
+puts "Entry for 'foo' with user 'bar': "
+pp db2
+puts "=" * 20

data/examples/yml/test_yml.rb

@@ -0,0 +1,28 @@
+#######################################################################
+# test_xml.rb
+#
+# Simple test script that uses the DBRC::XML subclass.
+#######################################################################
+if File.basename(Dir.pwd) == "yml"
+   Dir.chdir "../.."
+   $LOAD_PATH.unshift Dir.pwd + "/lib"
+   Dir.chdir "examples/yml"
+end
+
+require "dbi/dbrc"
+require "pp"
+include DBI
+
+puts "VERSION: " + DBRC::YML::VERSION
+
+# Use the .dbrc file in this directory
+db1 = DBRC::YML.new("foo",nil,Dir.pwd) # Get first entry found for 'foo'
+db2 = DBRC::YML.new("foo","user1",Dir.pwd) # Specify user
+
+puts "First entry found for 'foo': "
+pp db1
+puts "=" * 20
+
+puts "Entry for 'foo' with user 'bar': "
+pp db2
+puts "=" * 20

data/lib/dbi/dbrc.rb

@@ -0,0 +1,216 @@
+if File::ALT_SEPARATOR
+   require "win32/file"
+   include Win32
+end
+
+require "sys/admin"
+include Sys
+
+module DBI
+
+   # The base error class for dbi-dbrc.  If anything goes wrong, this is
+   # the error that is raised.  A subclass of StandardError.
+   class DBRCError < StandardError; end
+
+   # The main class.
+   class DBRC
+      VERSION = "1.0.0"
+      attr_accessor :database, :user, :password, :driver, :dsn
+      attr_accessor :maximum_reconnects, :timeout, :interval, :dbrc_dir
+
+      # Returns a new DBRC object.  The contents of the object depend on the
+      # arguments passed to the constructor.  If only a database name is
+      # passed, then the first entry found in the .dbrc file that matches that
+      # database is parsed.  If a user name is also included, then the first
+      # entry that matches both the database and user name is parsed.
+      #
+      # If a directory is passed as the third argument, then DBRC will look
+      # in that directory, instead of the default directory, for the .dbrc
+      # file.
+      #
+      # If an entry cannot be found for the database, or database plus user
+      # combination, then a DBRCError is raised.  If the .dbrc file cannot
+      # be found, or is setup improperly with regards to permissions or
+      # properties, a DBRCError is raised.
+      def initialize(database,user=nil,dbrc_dir=nil)
+         if dbrc_dir.nil?
+            if File::ALT_SEPARATOR
+               home = ENV["USERPROFILE"] || ENV["HOME"]
+               file = nil
+               
+               if home
+                  file = home + "\\.dbrc"
+               else
+                  file = "C:\\Documents and Settings\\"
+                  file += Admin.get_user(Admin.get_login).home_dir + "\\.dbrc"
+               end
+               
+               @dbrc_file = file
+            else
+               @dbrc_file = Admin.get_user(Process.uid).dir + "/.dbrc"
+            end
+         else
+            @dbrc_file = dbrc_dir + "/.dbrc"
+         end
+         
+         @database  = database
+         @user      = user
+         encrypted  = false # Win32 only
+
+         check_file()
+         
+         # If on Win32 and the file is encrypted, decrypt it.
+         if File::ALT_SEPARATOR && File.encrypted?(@dbrc_file)
+            encrypted = true
+            File.decrypt(@dbrc_file)
+         end
+         
+         parse_dbrc_config_file()
+         validate_data()
+         convert_numeric_strings()
+         create_dsn_string()
+         
+         # If on Win32 and the file was encrypted, re-encrypt it
+         if File::ALT_SEPARATOR && encrypted
+            File.encrypt(@dbrc_file)
+         end
+      end
+
+      private
+
+      # Ensure that the user/password has been set
+      def validate_data
+         unless @user
+            raise DBRCError, "no user found associated with #{@database}"
+         end
+
+         unless @password
+            raise DBRCError, "password not defined for #{@user}@#{@database}"
+         end
+      end
+   
+      # Converts strings that should be numbers into actual numbers
+      def convert_numeric_strings
+         @interval   = @interval.to_i if @interval
+         @timeout    = @timeout.to_i if @timeout
+         @maximum_reconnects = @maximum_reconnects.to_i if @maximum_reconnects
+      end
+
+      # Create the dsn string if the driver is defined
+      def create_dsn_string
+         @dsn = "dbi:#{@driver}:#{@database}" if @driver
+      end
+
+      # Check ownership and permissions
+      def check_file(file=@dbrc_file)
+         File.open(file){ |f|
+
+            # Permissions must be set to 600 or better on Unix systems.
+            # Must be hidden on Win32 systems.
+            if File::ALT_SEPARATOR
+               unless File.hidden?(file)
+                  raise DBRCError, "The .dbrc file must be hidden"
+               end
+            else
+               unless (f.stat.mode & 077) == 0
+                  raise DBRCError, "Bad .dbrc file permissions"
+               end
+            end
+
+            # Only the owner may use it
+            unless f.stat.owned?
+               raise DBRCError, "Not owner of .dbrc file"
+            end
+         }
+      end
+
+      # Parse the text out of the .dbrc file.  This is the only method you
+      # need to redefine if writing your own config handler.
+      def parse_dbrc_config_file(file=@dbrc_file)
+         IO.foreach(file){ |line|
+            next if line =~ /^#/    # Ignore comments
+            db, user, pwd, driver, timeout, max, interval = line.split
+
+            next unless @database == db
+
+            if @user
+               next unless @user == user
+            end
+
+            @user               = user
+            @password           = pwd
+            @driver             = driver
+            @timeout            = timeout
+            @maximum_reconnects = max
+            @interval           = interval
+            return
+         }
+
+         # If we reach here it means the database and/or user wasn't found
+         raise DBRCError, "No record found for #{@user}@#{@database}"
+      end
+
+      alias_method(:db,:database)
+      alias_method(:db=,:database=)
+      alias_method(:passwd,:password)
+      alias_method(:passwd=,:password=)
+      alias_method(:max_reconn,:maximum_reconnects)
+      alias_method(:max_reconn=,:maximum_reconnects=)
+      alias_method(:time_out,:timeout)
+      alias_method(:time_out=,:timeout=)
+   end
+
+   # A subclass of DBRC designed to handle .dbrc files in XML format.  The
+   # public methods of this class are identical to DBRC.
+   class XML < DBRC
+      require "rexml/document"
+      include REXML
+      private
+      def parse_dbrc_config_file(file=@dbrc_file)
+         doc = Document.new(File.new(file))
+         fields = %w/user password driver interval timeout maximum_reconnects/
+         doc.elements.each("/dbrc/database"){ |element|
+            next unless element.attributes["name"] == database
+            if @user
+               next unless element.elements["user"].text == @user
+            end
+            fields.each{ |field|
+               val = element.elements[field]
+               unless val.nil?
+                  send("#{field}=",val.text)
+               end
+            }
+            return
+         }
+         # If we reach here it means the database and/or user wasn't found
+         raise DBRCError, "No record found for #{@user}@#{@database}"
+      end
+   end
+
+   # A subclass of DBRC designed to handle .dbrc files in YAML format. The
+   # public methods of this class are identical to DBRC.
+   class YML < DBRC
+      require "yaml"
+      private
+      def parse_dbrc_config_file(file=@dbrc_file)
+         config = YAML.load(File.open(file))
+         config.each{ |hash|
+            hash.each{ |db,info|
+               next unless db == @database
+               if @user
+                  next unless @user == info["user"]
+               end
+               @user       = info["user"]            
+               @password   = info["password"]
+               @driver     = info["driver"]
+               @interval   = info["interval"]
+               @timeout    = info["timeout"]
+               @maximum_reconnects = info["max_reconn"]
+               return
+            }
+         }
+         # If we reach this point, it means the database wasn't found
+         raise DBRCError, "No entry found for #{@user}@#{@database}"
+      end
+   end
+end

data/test/tc_dbrc.rb

@@ -0,0 +1,183 @@
+######################################################
+# tc_dbrc.rb
+#
+# Test suite for the base class of DBI::DBRC.
+######################################################
+base = File.basename(Dir.pwd)
+
+if base == "test" || base =~ /dbi-dbrc/
+   Dir.chdir("..") if base == "test"
+   $LOAD_PATH.unshift(Dir.pwd + "/lib")
+   Dir.chdir("test") rescue nil
+end
+
+require "dbi/dbrc"
+require "test/unit"
+include DBI
+
+class TC_DBRC < Test::Unit::TestCase
+   def setup
+      @dir      = "../examples/plain"
+      @file     = @dir + "/.dbrc"
+      @db1      = "foo"
+      @db2      = "bar"
+      @user1    = "user1"
+      @user2    = "user2"
+      @db_bad   = "blah"  # Doesn't exist
+      @user_bad = "user8" # Doesn't exist
+     
+      if File::ALT_SEPARATOR
+         File.set_attr(@file,File::HIDDEN)
+      else
+         File.chmod(0600, @file)
+      end
+      
+      @dbrc = DBRC.new(@db1, nil, @dir)
+   end
+
+   def test_version
+      assert_equal("1.0.0", DBRC::VERSION)
+   end
+
+   def test_bad_dbrc_properties
+      if File::ALT_SEPARATOR
+         File.unset_attr(@file, File::HIDDEN)
+         assert_raises(DBRCError){ DBRC.new(@db1, @user1, @dir) }
+      else
+         File.chmod(0555,@file)
+         assert_raises(DBRCError){ DBRC.new(@db1, @user1, @dir) }
+      end
+   end
+
+   def test_constructor
+      assert_raises(ArgumentError){ DBRC.new }
+      assert_nothing_raised{ DBRC.new(@db1, @user1, @dir) }
+      assert_nothing_raised{ DBRC.new(@db1, nil, @dir) }
+   end
+
+   def test_bad_database
+      assert_raises(DBRCError){ DBRC.new(@db_bad, nil, @dir) }
+   end
+
+   def test_bad_user
+      assert_raises(DBRCError){ DBRC.new(@db1, @user_bad, @dir) }
+   end
+
+   def test_database
+      assert_respond_to(@dbrc, :database)
+      assert_respond_to(@dbrc, :database=)
+      assert_respond_to(@dbrc, :db)
+      assert_respond_to(@dbrc, :db=)
+      assert_kind_of(String, @dbrc.db)
+   end
+
+   def test_dsn
+      assert_respond_to(@dbrc, :dsn)
+      assert_respond_to(@dbrc, :dsn=)
+   end
+
+   def test_user
+      assert_respond_to(@dbrc, :user)
+      assert_respond_to(@dbrc, :user=)
+      assert_kind_of(String, @dbrc.user)
+   end
+
+   def test_password
+      assert_respond_to(@dbrc, :password)
+      assert_respond_to(@dbrc, :password=)
+      assert_respond_to(@dbrc, :passwd)
+      assert_respond_to(@dbrc, :passwd=)
+      assert_kind_of(String, @dbrc.password)
+   end
+
+   def test_driver
+      assert_respond_to(@dbrc, :driver)
+      assert_respond_to(@dbrc, :driver=)
+      assert_kind_of(String, @dbrc.driver)
+   end
+
+   def test_interval
+      assert_respond_to(@dbrc, :interval)
+      assert_respond_to(@dbrc, :interval=)
+      assert_kind_of(Fixnum, @dbrc.interval)
+   end
+
+   def test_timeout
+      assert_respond_to(@dbrc, :timeout)
+      assert_respond_to(@dbrc, :timeout=)
+      assert_respond_to(@dbrc, :time_out)
+      assert_respond_to(@dbrc, :time_out=)
+      assert_kind_of(Fixnum, @dbrc.timeout)
+   end
+
+   def test_max_reconn
+      assert_respond_to(@dbrc, :max_reconn)
+      assert_respond_to(@dbrc, :max_reconn=)
+      assert_respond_to(@dbrc, :maximum_reconnects)
+      assert_respond_to(@dbrc, :maximum_reconnects=)
+      assert_kind_of(Fixnum, @dbrc.maximum_reconnects)
+   end
+
+   def test_sample_values
+      assert_equal("foo", @dbrc.database)
+      assert_equal("user1", @dbrc.user)
+      assert_equal("pwd1", @dbrc.passwd)
+      assert_equal("Oracle", @dbrc.driver)
+      assert_equal(60, @dbrc.interval)
+      assert_equal(40, @dbrc.timeout)
+      assert_equal(3, @dbrc.max_reconn)
+      assert_equal("dbi:Oracle:foo", @dbrc.dsn)
+   end
+
+   # Same database, different user
+   def test_duplicate_database
+      db = DBRC.new("foo", "user2", @dir) 
+      assert_equal("user2", db.user)
+      assert_equal("pwd2", db.passwd)
+      assert_equal("OCI8", db.driver)
+      assert_equal(60, db.interval)
+      assert_equal(60, db.timeout)
+      assert_equal(4, db.max_reconn)
+      assert_equal("dbi:OCI8:foo", db.dsn)
+   end
+
+   # Different database, different user
+   def test_different_database
+      db = DBRC.new("bar", "user1", @dir)
+      assert_equal("user1", db.user)
+      assert_equal("pwd3", db.passwd)
+      assert_equal("Oracle", db.driver)
+      assert_equal(30, db.interval)
+      assert_equal(30, db.timeout)
+      assert_equal(2, db.max_reconn)
+      assert_equal("dbi:Oracle:bar", db.dsn)
+   end
+
+   # A database with only a couple fields defined
+   def test_nil_values
+      db = DBRC.new("baz", "user3", @dir) 
+      assert_equal("user3", db.user)
+      assert_equal("pwd4", db.passwd)
+      assert_nil(db.driver)
+      assert_nil(db.interval)
+      assert_nil(db.timeout)
+      assert_nil(db.max_reconn)
+      assert_nil(db.dsn)
+   end
+
+   def teardown
+      @dir      = nil
+      @db1      = nil
+      @db2      = nil
+      @user1    = nil
+      @user2    = nil
+      @db_bad   = nil
+      @user_bad = nil
+      @dbrc     = nil
+      if File::ALT_SEPARATOR
+         File.set_attr(@file, File::HIDDEN)
+      else
+         File.chmod(0600, @file)
+      end
+   end
+end

data/test/tc_dbrc_xml.rb

@@ -0,0 +1,165 @@
+#################################################################
+# tc_dbrc_xml.rb
+#
+# Test suite for the XML specific version of DBI::DBRC.
+#################################################################
+base = File.basename(Dir.pwd)
+
+if base == "test" || base =~ /dbi-dbrc/
+   Dir.chdir("..") if base == "test"
+   $LOAD_PATH.unshift(Dir.pwd + "/lib")
+   Dir.chdir("test") rescue nil
+end
+
+require "dbi/dbrc"
+require "test/unit"
+require "rexml/document"
+include REXML
+include DBI
+
+class TC_DBRC_XML < Test::Unit::TestCase
+   def setup
+      @dir      = "../examples/xml"
+      @file     = @dir + "/.dbrc"
+      @db1      = "foo"
+      @db2      = "bar"
+      @user1    = "user1"
+      @user2    = "user2"
+      @db_bad   = "blah"  # Doesn't exist
+      @user_bad = "user8" # Doesn't exist
+
+      @dbrc = DBRC::XML.new(@db1, nil, @dir)
+      File.chmod(0600, @file)
+   end
+
+   def test_version
+      assert_equal("1.0.0", DBRC::XML::VERSION)
+   end
+
+   def test_constructor
+      assert_raises(ArgumentError){ DBRC::XML.new }
+      assert_nothing_raised{ DBRC::XML.new(@db1, @user1, @dir) }
+      assert_nothing_raised{ DBRC::XML.new(@db1, nil, @dir) }
+   end
+
+   def test_bad_database
+      assert_raises(DBRCError){ DBRC::XML.new(@db_bad, nil, @dir) }
+   end
+
+   def test_bad_user
+      assert_raises(DBRCError){ DBRC::XML.new(@db1, @user_bad, @dir) }
+   end
+
+   def test_database
+      assert_respond_to(@dbrc, :database)
+      assert_respond_to(@dbrc, :database=)
+      assert_respond_to(@dbrc, :db)
+      assert_respond_to(@dbrc, :db=)
+      assert_kind_of(String, @dbrc.db)
+   end
+
+   def test_dsn
+      assert_respond_to(@dbrc, :dsn)
+      assert_respond_to(@dbrc, :dsn=)
+   end
+
+   def test_user
+      assert_respond_to(@dbrc, :user)
+      assert_respond_to(@dbrc, :user=)
+      assert_kind_of(String, @dbrc.user)
+   end
+
+   def test_password
+      assert_respond_to(@dbrc, :password)
+      assert_respond_to(@dbrc, :password=)
+      assert_respond_to(@dbrc, :passwd)
+      assert_respond_to(@dbrc, :passwd=)
+      assert_kind_of(String, @dbrc.password)
+   end
+
+   def test_driver
+      assert_respond_to(@dbrc, :driver)
+      assert_respond_to(@dbrc, :driver=)
+      assert_kind_of(String, @dbrc.driver)
+   end
+
+   def test_interval
+      assert_respond_to(@dbrc, :interval)
+      assert_respond_to(@dbrc, :interval=)
+      assert_kind_of(Fixnum, @dbrc.interval)
+   end
+
+   def test_timeout
+      assert_respond_to(@dbrc, :timeout)
+      assert_respond_to(@dbrc, :timeout=)
+      assert_respond_to(@dbrc, :time_out)
+      assert_respond_to(@dbrc, :time_out=)
+      assert_kind_of(Fixnum, @dbrc.timeout)
+   end
+
+   def test_max_reconn
+      assert_respond_to(@dbrc, :max_reconn)
+      assert_respond_to(@dbrc, :max_reconn=)
+      assert_respond_to(@dbrc, :maximum_reconnects)
+      assert_respond_to(@dbrc, :maximum_reconnects=)
+      assert_kind_of(Fixnum, @dbrc.maximum_reconnects)
+   end
+
+   def test_sample_values
+      assert_equal("foo", @dbrc.database)
+      assert_equal("user1", @dbrc.user)
+      assert_equal("pwd1", @dbrc.passwd)
+      assert_equal("Oracle", @dbrc.driver)
+      assert_equal(60, @dbrc.interval)
+      assert_equal(40, @dbrc.timeout)
+      assert_equal(3, @dbrc.max_reconn)
+      assert_equal("dbi:Oracle:foo", @dbrc.dsn)
+   end
+
+   # Same database, different user
+   def test_duplicate_database
+      db = DBRC::XML.new("foo", "user2", @dir) 
+      assert_equal("user2", db.user)
+      assert_equal("pwd2", db.passwd)
+      assert_equal("OCI8", db.driver)
+      assert_equal(60, db.interval)
+      assert_equal(60, db.timeout)
+      assert_equal(4, db.max_reconn)
+      assert_equal("dbi:OCI8:foo", db.dsn)
+   end
+
+   # Different database, different user
+   def test_different_database
+      db = DBRC::XML.new("bar", "user1", @dir)
+      assert_equal("user1", db.user)
+      assert_equal("pwd3", db.passwd)
+      assert_equal("Oracle", db.driver)
+      assert_equal(30, db.interval)
+      assert_equal(30, db.timeout)
+      assert_equal(2, db.max_reconn)
+      assert_equal("dbi:Oracle:bar", db.dsn)
+   end
+
+   # A database with only a couple fields defined
+   def test_nil_values
+      db = DBRC::XML.new("baz", "user3", @dir) 
+      assert_equal("user3", db.user)
+      assert_equal("pwd4", db.passwd)
+      assert_nil(db.driver)
+      assert_nil(db.interval)
+      assert_nil(db.timeout)
+      assert_nil(db.max_reconn)
+      assert_nil(db.dsn)
+   end
+
+   def teardown
+      @dir      = nil
+      @db1      = nil
+      @db2      = nil
+      @user1    = nil
+      @user2    = nil
+      @db_bad   = nil
+      @user_bad = nil
+      @dbrc     = nil
+   end
+end

data/test/tc_dbrc_yml.rb

@@ -0,0 +1,174 @@
+#################################################################
+# tc_dbrc_yml.rb
+#
+# Test suite for the YAML specific version of DBI::DBRC.
+#################################################################
+base = File.basename(Dir.pwd)
+
+if base == "test" || base =~ /dbi-dbrc/
+   Dir.chdir("..") if base == "test"
+   $LOAD_PATH.unshift(Dir.pwd + "/lib")
+   Dir.chdir("test") rescue nil
+end
+
+require "dbi/dbrc"
+require "test/unit"
+include DBI
+
+class TC_DBRC_YML < Test::Unit::TestCase
+   def setup
+      @dir      = "../examples/yml"
+      @file     = @dir + "/.dbrc"
+      @db1      = "foo"
+      @db2      = "bar"
+      @user1    = "user1"
+      @user2    = "user2"
+      @db_bad   = "blah"  # Doesn't exist
+      @user_bad = "user8" # Doesn't exist
+
+      if File::ALT_SEPARATOR
+         File.set_attr(@file, File::HIDDEN)
+      else
+         File.chmod(0600, @file)
+      end
+
+      @dbrc = DBRC::YML.new(@db1, nil, @dir)
+   end
+
+   def test_version
+      assert_equal("1.0.0", DBRC::YML::VERSION)
+   end
+
+   def test_constructor
+      assert_raises(ArgumentError){ DBRC::YML.new }
+      assert_nothing_raised{ DBRC::YML.new(@db1, @user1, @dir) }
+      assert_nothing_raised{ DBRC::YML.new(@db1, nil, @dir) }
+   end
+
+   def test_bad_database
+      assert_raises(DBRCError){ DBRC::YML.new(@db_bad, nil, @dir) }
+   end
+
+   def test_bad_user
+      assert_raises(DBRCError){ DBRC::YML.new(@db1, @user_bad, @dir) }
+   end
+
+   def test_database
+      assert_respond_to(@dbrc, :database)
+      assert_respond_to(@dbrc, :database=)
+      assert_respond_to(@dbrc, :db)
+      assert_respond_to(@dbrc, :db=)
+      assert_kind_of(String, @dbrc.db)
+   end
+
+   def test_dsn
+      assert_respond_to(@dbrc, :dsn)
+      assert_respond_to(@dbrc, :dsn=)
+   end
+
+   def test_user
+      assert_respond_to(@dbrc, :user)
+      assert_respond_to(@dbrc, :user=)
+      assert_kind_of(String, @dbrc.user)
+   end
+
+   def test_password
+      assert_respond_to(@dbrc, :password)
+      assert_respond_to(@dbrc, :password=)
+      assert_respond_to(@dbrc, :passwd)
+      assert_respond_to(@dbrc, :passwd=)
+      assert_kind_of(String, @dbrc.password)
+   end
+
+   def test_driver
+      assert_respond_to(@dbrc, :driver)
+      assert_respond_to(@dbrc, :driver=)
+      assert_kind_of(String, @dbrc.driver)
+   end
+
+   def test_interval
+      assert_respond_to(@dbrc, :interval)
+      assert_respond_to(@dbrc, :interval=)
+      assert_kind_of(Fixnum, @dbrc.interval)
+   end
+
+   def test_timeout
+      assert_respond_to(@dbrc, :timeout)
+      assert_respond_to(@dbrc, :timeout=)
+      assert_respond_to(@dbrc, :time_out)
+      assert_respond_to(@dbrc, :time_out=)
+      assert_kind_of(Fixnum, @dbrc.timeout)
+   end
+
+   def test_max_reconn
+      assert_respond_to(@dbrc, :max_reconn)
+      assert_respond_to(@dbrc, :max_reconn=)
+      assert_respond_to(@dbrc, :maximum_reconnects)
+      assert_respond_to(@dbrc, :maximum_reconnects=)
+      assert_kind_of(Fixnum, @dbrc.maximum_reconnects)
+   end
+
+   def test_sample_values
+      assert_equal("foo", @dbrc.database)
+      assert_equal("user1", @dbrc.user)
+      assert_equal("pwd1", @dbrc.passwd)
+      assert_equal("Oracle", @dbrc.driver)
+      assert_equal(60, @dbrc.interval)
+      assert_equal(40, @dbrc.timeout)
+      assert_equal(3, @dbrc.max_reconn)
+      assert_equal("dbi:Oracle:foo", @dbrc.dsn)
+   end
+
+   # Same database, different user
+   def test_duplicate_database
+      db = DBRC::YML.new("foo", "user2", @dir) 
+      assert_equal("user2", db.user)
+      assert_equal("pwd2", db.passwd)
+      assert_equal("OCI8", db.driver)
+      assert_equal(60, db.interval)
+      assert_equal(60, db.timeout)
+      assert_equal(4, db.max_reconn)
+      assert_equal("dbi:OCI8:foo", db.dsn)
+   end
+
+   # Different database, different user
+   def test_different_database
+      db = DBRC::YML.new("bar", "user1", @dir)
+      assert_equal("user1", db.user)
+      assert_equal("pwd3", db.passwd)
+      assert_equal("Oracle", db.driver)
+      assert_equal(30, db.interval)
+      assert_equal(30, db.timeout)
+      assert_equal(2, db.max_reconn)
+      assert_equal("dbi:Oracle:bar", db.dsn)
+   end
+
+   # A database with only a couple fields defined
+   def test_nil_values
+      db = DBRC::YML.new("baz", "user3", @dir) 
+      assert_equal("user3", db.user)
+      assert_equal("pwd4", db.passwd)
+      assert_nil(db.driver)
+      assert_nil(db.interval)
+      assert_nil(db.timeout)
+      assert_nil(db.max_reconn)
+      assert_nil(db.dsn)
+   end
+
+   def teardown
+      @dir      = nil
+      @db1      = nil
+      @db2      = nil
+      @user1    = nil
+      @user2    = nil
+      @db_bad   = nil
+      @user_bad = nil
+      @dbrc     = nil
+
+      if File::ALT_SEPARATOR
+         File.set_attr(@file, File::HIDDEN)
+      else
+         File.chmod(0600, @file)
+      end
+   end
+end

data/test/ts_all.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift(Dir.pwd)
+$LOAD_PATH.unshift(Dir.pwd + "/test")
+
+require "tc_dbrc"
+require "tc_dbrc_yml"
+require "tc_dbrc_xml"

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: dbi-dbrc
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2005-06-15
+summary: A simple way to avoid hard-coding passwords with DBI
+require_paths: 
+- lib
+email: djberg96@gmail.com
+homepage: http://www.rubyforge.org/projects/shards
+rubyforge_project: 
+description: A simple way to avoid hard-coding passwords with DBI
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+- Daniel Berger
+files: 
+- examples/plain
+- examples/xml
+- examples/yml
+- examples/plain/test.rb
+- examples/xml/test_xml.rb
+- examples/yml/test_yml.rb
+- lib/dbi
+- lib/dbi/dbrc.rb
+- test/tc_dbrc.rb
+- test/tc_dbrc_xml.rb
+- test/tc_dbrc_yml.rb
+- test/ts_all.rb
+- README
+- CHANGES
+test_files: 
+- test/ts_all.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- CHANGES
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+