lib/rake/delphi/tool.rb in rake-delphi-0.0.4 vs lib/rake/delphi/tool.rb in rake-delphi-0.0.5

@@ -1,60 +1,68 @@
 # encoding: utf-8
 
 require 'rake/common/exectask'
+require 'rake/common/logger'
 require 'rake/delphi/projectinfo'
+require 'rake/delphi/envvariables'
 
 module Rake
   module Delphi
     class CustomDelphiTool < CustomExec
         DelphiRegRoot =  'SOFTWARE\\Borland\\Delphi'
         BDSRegRoot = 'SOFTWARE\\Borland\\BDS'
         EDSRegRoot = 'SOFTWARE\\CodeGear\\BDS'
+        EmbarcaderoRegRoot = 'SOFTWARE\\Embarcadero\\BDS'
 
         # used mainly in tests
         def self.reinit
             @@version, @@delphidir, @@toolpath = nil, nil, nil
         end
+
         reinit
 
-        def initialize
-            @@version, @@delphidir, @@toolpath = self.class.find unless @@version
+        def initialize(checkExistance = false)
+            @@version, @@delphidir, @@toolpath = self.class.find(checkExistance) unless @@version
         end
 
         def self.toolName
             raise 'Abstract method "toolName". Override it'
         end
 
         def version
             @@version
         end
 
-        def delphidir
-            @@delphidir
-        end
-
         def toolpath
             @@toolpath
         end
 
         def versionInfoClass
-            return @@version.to_f < 11 ? BDSVersionInfo : RAD2007VersionInfo
+            return @@version.to_f < 11 ? BDSVersionInfo : \
+                @@version.to_f < 13 ? RAD2007VersionInfo : \
+                @@version.to_f < 14 ? RAD2010VersionInfo : XEVersionInfo
         end
 
         def self.readUserOption(key, name, ver)
             begin
                 require 'win32/registry'
                 root = rootForVersion(ver) + '\\' + key
+                key_exists = false
                 begin
+                    Logger.trace(Logger::DEBUG, "Reading user option '#{name}' in '#{root}'")
                     ::Win32::Registry::HKEY_CURRENT_USER.open(root) do |reg|
+                        key_exists = true
                         reg_typ, reg_val = reg.read(name)
                         return reg_val.gsub('\\', '/')
                     end
                 rescue ::Win32::Registry::Error
+                    Logger.trace(Logger::DEBUG, "No reg key '%s'?!" % \
+                      (key_exists ? "#{root}\\#{name}" : root))
                     return ''
                 end
             rescue LoadError
+                Logger.trace(Logger::DEBUG, 'No `win32/registry` gem?!')
                 return ''
             end
         end
 
         def self.version4version(version)
@@ -71,69 +79,93 @@
             if version.to_f < 9
                 regRoot = DelphiRegRoot
             else
                 if version.to_f < 12
                     regRoot = BDSRegRoot
-                else
+                elsif version.to_f < 14
                     regRoot = EDSRegRoot
+                else
+                    regRoot = EmbarcaderoRegRoot
                 end
             end
             version = version4version(version)
-            return regRoot + '\\' + version
+            regRoot = regRoot + '\\' + version
+            Logger.trace(Logger::DEBUG, "Root for version #{version}: '#{regRoot}'")
+            return regRoot
         end
 
         def self.readDelphiDir(ver)
             begin
                 require 'win32/registry'
                 [::Win32::Registry::HKEY_LOCAL_MACHINE, \
                         # for local/manual installations
                         ::Win32::Registry::HKEY_CURRENT_USER].each do |regRoot|
                     begin
+                        Logger.trace(Logger::DEBUG, "Finding Delphi dir for #{ver}")
                         regRoot.open(rootForVersion(ver)) do |reg|
                             reg_typ, reg_val = reg.read('RootDir')
                             return reg_val.gsub('\\', '/')
                         end
                     rescue ::Win32::Registry::Error
+                        Logger.trace(Logger::DEBUG, "No reg key '#{regRoot}'?!")
                     end
                 end
                 return nil
             rescue LoadError
+                Logger.trace(Logger::DEBUG, 'No `win32/registry` gem?!')
                 return nil
             end
         end
 
         def self.find(failIfNotFound = false)
-            v = ENV['DELPHI_VERSION']
+            v = EnvVariables.delphi_version
             if ENV['DELPHI_DIR']
+                Logger.trace(Logger::DEBUG, 'DELPHI_DIR is set: ' + ENV['DELPHI_DIR'])
                 # append trailing path delimiter
                 ENV['DELPHI_DIR'] = ENV['DELPHI_DIR'].gsub(/[^\/]$/, '\&/')
                 tool = ENV['DELPHI_DIR'] + toolName
                 checkToolFailure(tool) if failIfNotFound
                 return v, ENV['DELPHI_DIR'], tool
             end
             if v.to_s.empty?
                 v = []
-                (4..14).each { |n| v << n.to_s }
+                (4..20).each { |n| v << n.to_s }
                 v.reverse!
             else
+                Logger.trace(Logger::DEBUG, 'DELPHI_VERSION is set: ' + v)
                 v = [v]
             end
+            tool_was_found = false
             v.each do |ver|
                 path = readDelphiDir(ver)
                 next unless path
                 tool = path + toolName
+                tool_was_found = true
+                Logger.trace(Logger::DEBUG, "Got tool: '#{tool}'")
                 if File.exists?(tool) # found it !
                     ENV['DELPHI_VERSION'] = ver
                     ENV['DELPHI_DIR'] = path
+                    Logger.trace(Logger::DEBUG, "Set: DELPHI_VERSION=#{ver}; DELPHI_DIR='#{path}'")
                     return ver, path, tool
+                else
+                    Logger.trace(Logger::DEBUG, 'But file does not exist!')
                 end
             end
-            checkToolFailure(nil) if failIfNotFound
+            checkToolFailure(tool_was_found) if failIfNotFound
             return nil
         end
 
         def self.checkToolFailure(toolpath)
-            fail 'Could not find %s: (%s)' % [toolName, toolpath.to_s] unless File.exists?(toolpath.to_s)
+            if toolpath.kind_of?(TrueClass) || toolpath.kind_of?(FalseClass)
+                unless toolpath
+                    fail 'Could not detect path for %s! Check your registry and DELPHI_VERSION environment variable.' % [toolName]
+                end
+                cond = ! toolpath
+                toolpath = ''
+            else
+              cond = File.exists?(toolpath)
+            end
+            fail 'Could not find %s: (%s)' % [toolName, toolpath] unless cond
         end
 
     end
   end
 end