rUtilAnts 0.3.0.20110825 → 1.0.0.20120223

data/lib/rUtilAnts/Misc.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2009 - 2011 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
 # Licensed under the terms specified in LICENSE file. No warranty is provided.
 #++
 
@@ -8,20 +8,20 @@ module RUtilAnts
   module Misc
 
     # Set these methods into the Object namespace
-    def self.initializeMisc
+    def self.install_misc_on_object
       Object.module_eval('include RUtilAnts::Misc')
     end
 
     # Cache the access to a given code result, based on the caller ID
-    # This can be used to cache variables computation (ex. lVar = cachedVar{ lengthyFctToComputeVar } )
+    # This can be used to cache variables computation (ex. lVar = cached_var{ lengthyFctToComputeVar } )
     #
-    # Parameters:
+    # Parameters::
     # * *&iCode* (_CodeBlock_): The code called to compute the result
-    # ** Return:
-    # *** _Object_: The computed result
-    # Return:
+    #   * Return::
+    #     * _Object_: The computed result
+    # Return::
     # * _Object_: The result of the code
-    def cachedVar(&iCode)
+    def cached_var(&iCode)
       if (defined?(@RUtilAnts_Misc_CachedVars) == nil)
         @RUtilAnts_Misc_CachedVars = {}
       end
@@ -36,13 +36,13 @@ module RUtilAnts
 
     # Get a valid file name, taking into account platform specifically prohibited characters in file names.
     #
-    # Parameters:
+    # Parameters::
     # * *iFileName* (_String_): The original file name wanted
-    # Return:
+    # Return::
     # * _String_: The correct file name
-    def getValidFileName(iFileName)
-      if ((defined?($rUtilAnts_Platform_Info) != nil))
-        return iFileName.gsub(/[#{Regexp.escape($rUtilAnts_Platform_Info.getProhibitedFileNamesCharacters)}]/, '_')
+    def get_valid_file_name(iFileName)
+      if (defined?(getProhibitedFileNamesCharacters) != nil)
+        return iFileName.gsub(/[#{Regexp.escape(getProhibitedFileNamesCharacters)}]/, '_')
       else
         return iFileName
       end
@@ -50,24 +50,24 @@ module RUtilAnts
 
     # Extract a Zip archive in a given system dependent lib sub-directory
     #
-    # Parameters:
+    # Parameters::
     # * *iZipFileName* (_String_): The zip file name to extract content from
     # * *iDirName* (_String_): The name of the directory to store the zip to
-    # Return:
+    # Return::
     # * _Exception_: Error, or nil in case of success
-    def extractZipFile(iZipFileName, iDirName)
+    def extract_zip_file(iZipFileName, iDirName)
       rError = nil
 
       # Use RDI if possible to ensure the dependencies on zlib.dll and rubyzip
       if (defined?(RDI) != nil)
-        lRDIInstaller = RDI::Installer.getMainInstance
+        lRDIInstaller = RDI::Installer.get_main_instance
         if (lRDIInstaller != nil)
           # First, test that the DLL exists.
           # If it does not exist, we can't install it, because ZLib.dll is downloadable only in ZIP format (kind of stupid ;-) )
           lDLLDep = nil
-          case $rUtilAnts_Platform_Info.os
+          case os
           when OS_WINDOWS
-            lDLLDep = RDI::Model::DependencyDescription.new('ZLib DLL').addDescription( {
+            lDLLDep = RDI::Model::DependencyDescription.new('ZLib DLL').add_description( {
               :Testers => [
                 {
                   :Type => 'DynamicLibraries',
@@ -78,21 +78,21 @@ module RUtilAnts
               :Installers => []
             } )
           else
-            logBug "Sorry, installing ZLib on your platform #{$rUtilAnts_Platform_Info.os} is not yet supported."
+            log_bug "Sorry, installing ZLib on your platform #{os} is not yet supported."
           end
           if ((lDLLDep != nil) and
-              (!lRDIInstaller.testDependency(lDLLDep)))
+              (!lRDIInstaller.test_dependency(lDLLDep)))
             # Try adding the default local location for libraries
-            lRDIInstaller.ensureLocationInContext('LibraryPath', lRDIInstaller.getDefaultInstallLocation('Download', RDI::DEST_LOCAL))
+            lRDIInstaller.ensure_location_in_context('LibraryPath', lRDIInstaller.get_default_install_location('Download', RDI::DEST_LOCAL))
             # Try again
-            if (!lRDIInstaller.testDependency(lDLLDep))
-              logErr "zlib.dll is not installed in your system.\nUnfortunately RDI can't help because the only way to install it is to download it through a ZIP file.\nPlease install it manually from http://zlib.net (you can do it now and click OK once it is installed)."
+            if (!lRDIInstaller.test_dependency(lDLLDep))
+              log_err "zlib.dll is not installed in your system.\nUnfortunately RDI can't help because the only way to install it is to download it through a ZIP file.\nPlease install it manually from http://zlib.net (you can do it now and click OK once it is installed)."
             end
           end
           # Then, ensure the gem dependency
-          rError, lCMApplied, lIgnored, lUnresolved = lRDIInstaller.ensureDependencies(
+          rError, lCMApplied, lIgnored, lUnresolved = lRDIInstaller.ensure_dependencies(
             [
-              RDI::Model::DependencyDescription.new('RubyZip').addDescription( {
+              RDI::Model::DependencyDescription.new('RubyZip').add_description( {
                 :Testers => [
                   {
                     :Type => 'RubyRequires',
@@ -152,10 +152,10 @@ module RUtilAnts
     # Execute a code block after having changed current directory.
     # Ensure the directory will be changed back at the end of the block, even if exceptions are thrown.
     #
-    # Parameters:
+    # Parameters::
     # * *iDir* (_String_): The directory to change into
     # * *CodeBlock*: Code called once the current directory has been changed
-    def changeDir(iDir)
+    def change_dir(iDir)
       lOldDir = Dir.getwd
       Dir.chdir(iDir)
       begin
@@ -167,7 +167,7 @@ module RUtilAnts
       Dir.chdir(lOldDir)
     end
 
-    # Constants used for fileMutex
+    # Constants used for file_mutex
     # There was no lock on the mutex
     FILEMUTEX_NO_LOCK = 0
     # There was a lock on the mutex, but former process did not exist anymore
@@ -178,36 +178,36 @@ module RUtilAnts
     FILEMUTEX_INVALID_LOCK = 3
     # Execute a code block protected by a file mutex
     #
-    # Parameters:
+    # Parameters::
     # * *iProcessID* (_String_): Process ID to be used to identify the mutex
     # * *CodeBlock*: The code called if the mutex is taken
-    # Return:
+    # Return::
     # * _Integer_: Error code
-    def fileMutex(iProcessID)
+    def file_mutex(iProcessID)
       rResult = FILEMUTEX_NO_LOCK
 
       # Prevent concurrent execution
       require 'tmpdir'
       lLockFile = "#{Dir.tmpdir}/FileMutex_#{iProcessID}.lock"
       if (File.exists?(lLockFile))
-        logErr "Another instance of process #{iProcessID} is already running. Delete file #{lLockFile} if it is not."
+        log_err "Another instance of process #{iProcessID} is already running. Delete file #{lLockFile} if it is not."
         begin
           lDetails = nil
           File.open(lLockFile, 'r') do |iFile|
             lDetails = eval(iFile.read)
           end
-          logErr "Details of the running instance: #{lDetails.inspect}"
+          log_err "Details of the running instance: #{lDetails.inspect}"
           # If the process does not exist anymore, remove the lock file
           # TODO: Adapt this to non Unix systems
           if (File.exists?("/proc/#{lDetails[:PID]}"))
             rResult = FILEMUTEX_LOCK_TAKEN
           else
-            logErr "Process #{lDetails[:PID]} does not exist anymore. Removing lock file."
+            log_err "Process #{lDetails[:PID]} does not exist anymore. Removing lock file."
             File.unlink(lLockFile)
             rResult = FILEMUTEX_ZOMBIE_LOCK
           end
         rescue Exception
-          logErr "Invalid lock file #{lLockFile}: #{$!}."
+          log_err "Invalid lock file #{lLockFile}: #{$!}."
           rResult = FILEMUTEX_INVALID_LOCK
         end
       end
@@ -229,7 +229,7 @@ module RUtilAnts
           begin
             File.unlink(lLockFile)
           rescue Exception
-            logErr "Exception while deleting lock file #{lLockFile}: #{$!}"
+            log_err "Exception while deleting lock file #{lLockFile}: #{$!}"
           end
           raise
         end
@@ -238,6 +238,39 @@ module RUtilAnts
       return rResult
     end
 
+    # Replace variables of the form %{VariableName} from a string.
+    # Take values from a hash having :VariableName => 'VariableValue'.
+    # Works also recursively if a variable value contains again %{OtherVariableName}.
+    # Does not check if variables really exist (will replace any unknown variable with '').
+    #
+    # Parameters::
+    # * *iStr* (_String_): The string to replace from
+    # * *iVars* (<em>map<Symbol,String></em>): The variables
+    # Return::
+    # * _String_: The string replaced
+    def replace_vars(iStr, iVars)
+      rStr = iStr
+
+      lFinished = false
+      while (!lFinished)
+        lMatch = rStr.match(/^(.*[^%])%\{([^\}]+)\}(.*)$/)
+        if (lMatch == nil)
+          # Try with %{ at the beginning of the string
+          lMatch = rStr.match(/^%\{([^\}]+)\}(.*)$/)
+          if (lMatch == nil)
+            # No more occurrences
+            lFinished = true
+          else
+            rStr = "#{iVars[lMatch[1].to_sym]}#{lMatch[2]}"
+          end
+        else
+          rStr = "#{lMatch[1]}#{iVars[lMatch[2].to_sym]}#{lMatch[3]}"
+        end
+      end
+
+      return rStr
+    end
+
   end
 
 end

data/lib/rUtilAnts/MySQLPool.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2011 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Copyright (c) 2011 - 2012 Muriel Salvan (muriel@x-aeon.com)
 # Licensed under the terms specified in LICENSE file. No warranty is provided.
 #++
 
@@ -17,7 +17,7 @@ module RUtilAnts
     end
 
     # Set these methods into the Object namespace
-    def self.initializeMySQLPool
+    def self.install_mysql_pool_on_object
       Object.module_eval('include RUtilAnts::MySQLPool')
     end
 
@@ -26,15 +26,15 @@ module RUtilAnts
     # Reuse existing connections.
     # If the given password is nil, we force the reuse of an existing connection.
     #
-    # Parameters:
+    # Parameters::
     # * *iHost* (_String_): The host to connect to
     # * *iDBName* (_String_): The MySQL database name to connect to
     # * *iUser* (_String_): The user
     # * *iPassword* (_String_): The password. If nil, this will only try to reuse an existing connection [optional = nil]
-    # Return:
+    # Return::
     # * _Exception_: An error, or nil in case of success
     # * _MySQL_: The MySQL connection, or nil in case of failure
-    def connectToMySQL(iHost, iDBName, iUser, iPassword = nil)
+    def connect_to_mysql(iHost, iDBName, iUser, iPassword = nil)
       rError = nil
       rMySQL = nil
 
@@ -59,7 +59,7 @@ module RUtilAnts
 #            lMySQL.options(Mysql::OPT_WRITE_TIMEOUT, 28800)
 #            lMySQL.real_connect(iHost, iUser, iPassword, iDBName)
           rescue Exception
-            logErr "Error while creating MySQL connection to #{lDBKey.inspect}: #{$!}.\n#{$!.backtrace.join("\n")}"
+            log_err "Error while creating MySQL connection to #{lDBKey.inspect}: #{$!}.\n#{$!.backtrace.join("\n")}"
             rError = $!
             lMySQL = nil
           end
@@ -80,11 +80,11 @@ module RUtilAnts
       return rError, rMySQL
     end
 
-    # Close a MySQL connection created with connectToMySQL
+    # Close a MySQL connection created with connect_to_mysql
     #
-    # Parameters:
+    # Parameters::
     # * *iMySQLConnection* (_MySQL_): The MySQL connection to close
-    def closeMySQL(iMySQLConnection)
+    def close_mysql(iMySQLConnection)
       # Find the connection
       if (defined?($RUtilAnts_MySQLPool_Pool) == nil)
         $RUtilAnts_MySQLPool_Pool = {}
@@ -100,24 +100,24 @@ module RUtilAnts
 
     # Setup a MySQL connection, and ensure it is closed once the client code ends.
     #
-    # Parameters:
+    # Parameters::
     # * *iHost* (_String_): The host to connect to
     # * *iDBName* (_String_): The MySQL database name to connect to
     # * *iUser* (_String_): The user
     # * *iPassword* (_String_): The password. If nil, this will only try to reuse an existing connection [optional = nil]
     # * *CodeBlock*: The code executed with the MySQL connection
-    # ** *iMySQL* (_MySQL_): The MySQL connection
-    # Return:
+    #   * *iMySQL* (_MySQL_): The MySQL connection
+    # Return::
     # * _Exception_: An error, or nil in case of success
-    def setupMySQLConnection(iHost, iDBName, iUser, iPassword = nil)
+    def setup_mysql_connection(iHost, iDBName, iUser, iPassword = nil)
       rError = nil
 
-      rError, lMySQL = connectToMySQL(iHost, iDBName, iUser, iPassword)
+      rError, lMySQL = connect_to_mysql(iHost, iDBName, iUser, iPassword)
       if (rError == nil)
         begin
           yield(lMySQL)
         ensure
-          closeMySQL(lMySQL)
+          close_mysql(lMySQL)
         end
       end
 
@@ -127,16 +127,16 @@ module RUtilAnts
     # Get a prepared statement for a given SQL string of a given MySQL connection.
     # Use the cache of prepared statements.
     #
-    # Parameters:
+    # Parameters::
     # * *iMySQLConnection* (_MySQL_): The MySQL connection
     # * *iStrSQL* (_String_): The SQL statement to prepare
     # * *iAdditionalOptions* (<em>map<Symbol,Object></em>): Additional options [optional = {}]
-    # ** *:LeaveOpen* (_Boolean_): Do we NOT close the opened statement once it is not used anymore ? [optional = false]
-    # Return:
+    #   * *:leave_open* (_Boolean_): Do we NOT close the opened statement once it is not used anymore ? [optional = false]
+    # Return::
     # * <em>MySQL::Statement</em>: The MySQL statement
-    def getPreparedStatement(iMySQLConnection, iStrSQL, iAdditionalOptions = {})
+    def get_prepared_statement(iMySQLConnection, iStrSQL, iAdditionalOptions = {})
       # Parse options
-      lLeaveOpen = iAdditionalOptions[:LeaveOpen] || false
+      lLeaveOpen = iAdditionalOptions[:leave_open] || false
       # Find the prepared statements set
       lPreparedStatements = $RUtilAnts_MySQLPool_Pool[findMySQLConnectionKey(iMySQLConnection)][2]
       if (lPreparedStatements[iStrSQL] == nil)
@@ -157,12 +157,12 @@ module RUtilAnts
       return lPreparedStatements[iStrSQL][0]
     end
 
-    # Close a previously created prepared statement using getPreparedStatement.
+    # Close a previously created prepared statement using get_prepared_statement.
     #
-    # Parameters:
+    # Parameters::
     # * *iMySQLConnection* (_MySQL_): The MySQL connection
     # * *iPreparedStatement* (<em>MySQL::Statement</em>): The MySQL prepared statement
-    def closePreparedStatement(iMySQLConnection, iPreparedStatement)
+    def close_prepared_statement(iMySQLConnection, iPreparedStatement)
       lPreparedStatements = $RUtilAnts_MySQLPool_Pool[findMySQLConnectionKey(iMySQLConnection)][2]
       lFound = false
       lPreparedStatements.each do |iStrSQL, ioPreparedStatementInfo|
@@ -186,19 +186,19 @@ module RUtilAnts
 
     # Setup a prepared statement, and ensure it will be closed
     #
-    # Parameters:
+    # Parameters::
     # * *iMySQLConnection* (_MySQL_): The MySQL connection
     # * *iStrSQL* (_String_): The SQL statement to prepare
     # * *iAdditionalOptions* (<em>map<Symbol,Object></em>): Additional options [optional = {}]
-    # ** *:LeaveOpen* (_Boolean_): Do we NOT close the opened statement once it is not used anymore ? [optional = false]
+    #   * *:leave_open* (_Boolean_): Do we NOT close the opened statement once it is not used anymore ? [optional = false]
     # * *CodeBlock*: The code executed once the statement is prepared
-    # ** *iPreparedStatement* (<em>MySQL::Statement</em>): The prepared statement
-    def setupPreparedStatement(iMySQLConnection, iStrSQL, iAdditionalOptions = {})
-      lStatement = getPreparedStatement(iMySQLConnection, iStrSQL, iAdditionalOptions)
+    #   * *iPreparedStatement* (<em>MySQL::Statement</em>): The prepared statement
+    def setup_prepared_statement(iMySQLConnection, iStrSQL, iAdditionalOptions = {})
+      lStatement = get_prepared_statement(iMySQLConnection, iStrSQL, iAdditionalOptions)
       begin
         yield(lStatement)
       ensure
-        closePreparedStatement(iMySQLConnection, lStatement)
+        close_prepared_statement(iMySQLConnection, lStatement)
       end
     end
 
@@ -206,9 +206,9 @@ module RUtilAnts
 
     # Find the MySQL connection key
     #
-    # Parameters:
+    # Parameters::
     # * *iMySQLConnection* (_MySQL_): The MySQL connection
-    # Return:
+    # Return::
     # * _String_: Host name, or nil if none
     # * _String_: DB name
     # * _String_: User name

data/lib/rUtilAnts/Platform.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2009 - 2011 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
 # Licensed under the terms specified in LICENSE file. No warranty is provided.
 #++
 
@@ -7,27 +7,44 @@ module RUtilAnts
 
   module Platform
 
+    module PlatformInterface
+
+      # Initialize the module
+      def self.includePlatformSpecificModule
+        # Require the platform info
+        begin
+          require "rUtilAnts/Platforms/#{RUBY_PLATFORM}/PlatformInfo"
+        rescue Exception
+          if (!defined?(log_bug))
+            require 'rUtilAnts/Logging'
+            RUtilAnts::Logging::install_logger_on_object
+          end
+          log_bug "Current platform #{RUBY_PLATFORM} is not supported (#{$!})."
+          raise RuntimeError, "Current platform #{RUBY_PLATFORM} is not supported (#{$!})."
+        end
+        # Include the platform specific module
+        PlatformInterface.module_eval('include RUtilAnts::Platform::PlatformInfo')
+      end
+
+      includePlatformSpecificModule
+
+    end
+
+    class Manager
+
+      include PlatformInterface
+
+    end
+
     # OS constants
     OS_WINDOWS = 0
     OS_LINUX = 1
     OS_CYGWIN = 2
 
     # Initialize the platform info
-    def self.initializePlatform
-      # Require the platform info
-      begin
-        require "rUtilAnts/Platforms/#{RUBY_PLATFORM}/PlatformInfo"
-      rescue Exception
-        if (!defined?(logBug))
-          require 'rUtilAnts/Logging'
-          RUtilAnts::Logging::initializeLogging(File.expand_path(File.dirname(__FILE__)), '')
-        end
-        logBug "Current platform #{RUBY_PLATFORM} is not supported (#{$!})."
-        raise RuntimeError, "Current platform #{RUBY_PLATFORM} is not supported (#{$!})."
-      end
-      # Create the corresponding object
-      $rUtilAnts_Platform_Info = PlatformInfo.new
-      Object.module_eval('include RUtilAnts::Platform')
+    def self.install_platform_on_object
+      require 'rUtilAnts/SingletonProxy'
+      RUtilAnts::make_singleton_proxy(RUtilAnts::Platform::PlatformInterface, Object)
     end
 
   end