rake-delphi 0.0.4

data/lib/rake/delphi/dcc32.rb

@@ -0,0 +1,260 @@
+# encoding: utf-8
+
+require 'rake'
+require 'rake/common/chdirtask'
+require 'rake/delphi/envvariables'
+require 'rake/delphi/resources'
+require 'rake/delphi/tool'
+require 'rake/helpers/rake'
+require 'rake/helpers/raketask'
+
+module Rake
+  module Delphi
+    class Dcc32Tool < CustomDelphiTool
+        def self.toolName
+            'bin/dcc32.exe'
+        end
+
+        def readLibraryPaths
+            libpaths = self.class.readUserOption('Library', 'Search Path', self.version).split(';') \
+                | self.class.readUserOption('Library', 'SearchPath', self.version).split(';')
+            dev = EnvVariables.new(self.class.rootForVersion(self.version) + '\Environment Variables', self.delphidir)
+            libpaths.map! do |lp|
+                if !lp.nil? && !lp.empty?
+                    lp = dev.expand(lp)
+                end
+                lp
+            end
+            return libpaths
+        end
+    end
+
+    class Dcc32Task < Rake::Task
+        attr_accessor :systempath, :mainicon, :_source, :exeoutput, :bin
+
+    private
+        @@symbols = [:quiet, :assertions, :build, :optimization, :debug, :defines,
+            :debuginfo, :localsymbols, :console, :warnings, :hints, :altercfg,
+            :includepaths, :writeableconst,
+            :map, :dcuoutput, :bploutput,
+            :dcpoutput, :dcu, :uselibrarypath, :uselibrarypath, :usecfg]
+    public
+        @@symbols.map do |sym|
+            attr_accessor sym
+        end
+
+        def initialize(name, application)
+            super
+            initvars
+            @arg_names = [:verbose]
+            @rc_template_task = application.define_task(RCTemplateTask, shortname + ':rc:template')
+            @rc_task = application.define_task(RCTask, shortname + ':rc')
+            enhance([@rc_template_task, @rc_task])
+            @dcc32Tool = Dcc32Tool.new
+        end
+
+        def versionInfoClass
+            @dcc32Tool.versionInfoClass
+        end
+
+    private
+        def initvars
+            @exeoutput = nil
+            @@symbols.map do |sym|
+                instance_variable_set("@#{sym.to_s}", nil)
+            end
+        end
+
+        def delphilibs
+            return [@dcc32Tool.delphidir + 'Lib'] | @dcc32Tool.readLibraryPaths
+        end
+
+        def _paths(ppaths)
+            ppaths.map! do |p|
+                a = []
+                ['U', 'I', 'R', 'O'].each do |s|
+                    a << Rake.quotepath("-#{s}", p)
+                end
+                a
+            end
+            # unique paths only
+            ppaths.flatten!.uniq!
+            ppaths
+        end
+
+        def implicitpaths
+            ipaths = ['.', '..']
+            ipaths |= delphilibs if @uselibrarypath
+            _paths(ipaths)
+        end
+
+        def paths
+            @includepaths ||= []
+            _paths(@includepaths)
+        end
+
+        def debug?
+            return @debug ? '-$D+ -$L+ -$YD -$C+ -$Q+ -$R+ -$O- -GD' : ''
+        end
+
+        def build?
+            return @build ? '-B' : '-M'
+        end
+
+        def warnings?
+            return @warnings ? '-W-' : '-W+'
+        end
+
+        def hints?
+            return @hints ? '-H-' : '-H+'
+        end
+
+        def quiet?
+            return @quiet ? '-Q' : ''
+        end
+
+        def exeoutput
+            return @exeoutput || @bin
+        end
+
+        def dcuoutput
+            return @dcuoutput || @dcu || @_source.pathmap('%d%sdcu')
+        end
+
+        def map
+            # segments -> -GS
+            # publics   -> -GP
+            # detailed  -> -GD
+            return unless @map
+            segments = @map.to_s[0..0].upcase
+            return '-G' + segments
+        end
+
+        def alldebuginfo
+            return @debuginfo ? '-$D+ -$L+ -$YD' : '-$D- -$L- -$Y-'
+        end
+
+        def outputs
+            os = []
+            os << Rake.quotepath('-E', exeoutput)
+            os << Rake.quotepath('-N', dcuoutput)
+            os << Rake.quotepath('-LE', @bploutput)
+            return os
+        end
+
+        def _source
+            return Rake.quotepath('', @_source)
+        end
+
+        def defines
+            '-D' + @defines if @defines
+        end
+
+        def writeableconst
+            return '-$J' + (@writeableconst ? '+' : '-')
+        end
+
+        def build_args
+            args = []
+            args << build? << warnings? << hints? << quiet? << debug? << alldebuginfo << map
+            args << defines << writeableconst
+            args << _source << outputs << implicitpaths
+            args.flatten
+        end
+
+    public
+        def init(properties)
+            pp properties if trace?
+            properties.map do |key, value|
+                instance_variable_set("@#{key}", value)
+            end
+            @_source = properties[:projectfile].pathmap('%X.dpr')
+            src = @_source.gsub('\\', '/')
+            dcu = src.pathmap('%d%sdcu')
+            # make sure to create dir for output dcu
+            # for now default is <PROJECTDIR>/dcu
+            directory dcu
+            enhance([dcu])
+            # mainicon is usually requested by RCTemplate
+            @mainicon ||= Rake.quotepath('', src.pathmap('%X.ico'))
+            @rc_template_task.output = src
+            @rc_template_task[:version] = properties[:version]
+            @rc_template_task[:releaseCandidate] = properties[:releaseCandidate]
+            @rc_task.input = src
+            @rc_task.is_rc = properties[:releaseCandidate]
+            return unless properties[:resources_additional]
+            res_add = properties[:resources_additional]
+            if res_add.kind_of?(String)
+                res_add = res_add.split(';')
+            end
+            c = 0
+            res_add.each do |res|
+                if res.kind_of?(Symbol)
+                    rc_task_add = res
+                else
+                    c = c.next
+                    rc_task_add = application.define_task(RCTask, shortname + ':rc:add' + c.to_s)
+                    rc_task_add.input = src.pathmap('%d%s') + res
+                end
+                enhance([rc_task_add])
+            end
+        end
+
+        def init_libs(libs = nil)
+            unless libs
+                # call parent to find libs
+                application[name.gsub(/:dcc32$/, '')].init_libs
+            else
+                # called from parent
+                # set libs
+                @includepaths = libs
+            end
+        end
+
+        def execute(opts=nil)
+            @dcc32Tool.class.checkToolFailure(@dcc32Tool.toolpath)
+            fail "Could not find #{_source} to compile" unless @_source && File.exists?(@_source)
+            init_libs
+            args = build_args
+            # on cygwin $D is assumed as shell var
+            # so escape $
+            args.map! { |a| a.gsub('$', '\$') if a.kind_of?(String) } unless application.windows?
+            args.compact!
+            cmd = Rake.quotepath('', @dcc32Tool.toolpath)
+            cmd << ([''] | args).join(' ')
+            ChDir.new(self, File.dirname(@_source)) do |dir|
+                RakeFileUtils.verbose(trace?) do
+                    begin
+                        unless @usecfg
+                            cfg = @systempath.pathmap('%X.cfg')
+                            bak_cfg = @systempath.pathmap('%X.rake.cfg')
+                            mv cfg, bak_cfg
+                            if @altercfg
+                                cp @altercfg, cfg
+                            end
+                            # on Windows there is some limit on command line parameters length
+                            # so we just append path parameters to config file
+                            File.open(cfg, 'a+') do |f|
+                                paths.each do |p|
+                                    f.write(p + "\n")
+                                end
+                                f.close
+                            end
+                        end
+                        sh cmd
+                    ensure
+                        unless @usecfg
+                            begin
+                                cp cfg, cfg + '.1' if trace?
+                            ensure
+                                mv bak_cfg, cfg
+                            end
+                        end
+                    end
+                end
+            end
+            puts '' # make one empty string to separate from further lines
+        end
+    end
+  end
+end

data/lib/rake/delphi/envvariables.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Rake
+  module Delphi
+    class EnvVariable
+        attr_reader :name
+        attr_accessor :value
+
+        def initialize(name, value)
+            @name, @value = name, value
+        end
+    end
+
+    class EnvVariables < ::Array
+        def initialize(regpath, delphidir)
+            _dir = delphidir.gsub(/\/$/, '')
+            add('DELPHI', _dir)
+            add('BDS', _dir)
+            expand_vars
+        end
+
+        def add(var, value)
+            self << EnvVariable.new(var, value)
+        end
+
+        def expand(value)
+            self.each do |ev|
+                value.gsub!("$(#{ev.name})", ev.value)
+            end
+            value
+        end
+
+        def expand_vars
+            self.map! do |v|
+                v.value = expand(v.value)
+                v
+            end
+        end
+    end
+  end
+end

data/lib/rake/delphi/liblist.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'rake/helpers/filelist'
+
+module Rake
+  module Delphi
+        class LibList < FileList
+            def read_ignored_libs
+                libs = []
+                file = (ENV['RAKE_DIR'] || Rake.original_dir) + '/.rake.ignored.libs'
+                return libs unless File.exists?(file)
+                IO.readlines(file).each do |line|
+                    # skip comment lines (started with # or ;)
+                    next if /^\s*[#;]/.match(line)
+                    libs << FileList.get_ignored_dir_pattern(line.chomp)
+                end
+                libs
+            end
+
+            alias_method :initialize_base, :initialize
+
+            def initialize(*patterns)
+                initialize_base(patterns)
+                @exclude_patterns |= read_ignored_libs
+                @exclude_procs << proc { |fn| File.file?(fn) }
+            end
+        end
+  end
+end

data/lib/rake/delphi/project.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+require 'rake'
+require 'rake/common/classes'
+require 'rake/common/libstask'
+require 'rake/delphi/dcc32'
+require 'rake/helpers/file'
+require 'rake/helpers/raketask'
+require 'rake/helpers/string'
+require 'pp'
+
+module Rake
+  module Delphi
+    class Project < Rake::Task
+        attr_accessor :properties
+
+        def initialize(name, app)
+            super
+            initvars
+            @dcc = application.define_task(Dcc32Task, shortname + ':dcc32')
+            @libs = LibsTask.define('all-delphi-libs', application)
+            @level = 1
+            enhance([@libs, @dcc])
+        end
+
+        def initvars
+            @properties = {
+                :build => true,
+                :warnings => false,
+                :hints => false,
+                :includepaths => nil
+            }
+            @cdir = ''
+        end
+
+        def init_libs
+            self[:includepaths] = ['.'] unless self[:includepaths]
+            self[:includepaths] |= @libs.libs_relative(@level)
+            @dcc.init_libs(self[:includepaths])
+        end
+
+        def init(module_name, rake_file, vars, level = 1)
+            @level = level
+            module_name = module_name.dup.pop.to_s
+            self[:projectlabel] = eval("#{module_name}::PROJECT_NAME")
+            projectfile = eval("#{module_name}::PROJECT_FILE")
+            self[:projectfile] = File.dirname2(rake_file) + File.separator +  projectfile
+            self[:sourcename] = File.dirname2(rake_file)
+            @cdir = File.dirname(rake_file)
+            self[:systempath] = @cdir + '/' + projectfile
+            self[:altercfg].prepend(self[:sourcename] + '/') if self[:altercfg]
+            [:version, :bin, :build, :dcu, :alldebuginfo, :map, :defines, :releaseCandidate].each do |k|
+                self[k] = vars[k] if vars.has_key?(k)
+            end if vars
+
+            @dcc.init(@properties)
+        end
+
+        def []=(key, value)
+            @properties[key.to_sym] = value
+        end
+
+        def [](key)
+            return @properties[key]
+        end
+    end
+  end
+end

data/lib/rake/delphi/projectinfo.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+require 'xmlsimple'
+require 'rake/helpers/rake'
+
+module Rake
+  module Delphi
+    class ProjectVersionInfo
+        def initialize(task)
+            @info = Hash.new
+            @file = task.systempath.pathmap('%X.' + self._ext)
+            do_getcontent
+        end
+
+        def do_getcontent
+            @content = nil
+        end
+
+        def _ext
+            ''
+        end
+
+        def [](key)
+            @info[key.to_sym]
+        end
+
+        def method_missing(name, *args, &block)
+            @info[name]
+        end
+    end
+
+    class BDSVersionInfo < ProjectVersionInfo
+        def initialize(task)
+            super(task)
+            content = @content['Delphi.Personality']['VersionInfoKeys']['VersionInfoKeys']
+            use_encode = String.new.respond_to?(:encode)
+            encoding = self.class.encoding
+            if encoding && ! use_encode
+                require 'iconv'
+                iconv = Iconv.new(encoding, 'UTF-8')
+            end
+            content.each do |v|
+                cv = v['content']
+                cv = (use_encode ? cv.encode(encoding, 'UTF-8') : iconv.iconv(cv)) if encoding
+                @info[v['Name'].to_sym] = cv
+            end
+        end
+
+        def self.encoding
+            # override to set your own encoding
+            nil
+        end
+
+        def do_getcontent
+            @content = XmlSimple.xml_in(@file, :ForceArray => false)
+        end
+
+        def _ext
+            return 'bdsproj'
+        end
+    end
+
+    class RAD2007VersionInfo < BDSVersionInfo
+        def _ext
+            return 'dproj'
+        end
+
+        def do_getcontent
+            super
+            # .dproj file has more nesting levels
+            @content = @content['ProjectExtensions']['BorlandProject']['BorlandProject']
+        end
+    end
+
+  end
+end

data/lib/rake/delphi/rc.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'rake/delphi/tool'
+
+module Rake
+  module Delphi
+    class RCResourceCompiler < CustomDelphiTool
+        def self.toolName
+            'bin/rc.exe'
+        end
+    end
+
+    class BorlandResourceCompiler < RCResourceCompiler
+        def self.toolName
+            'bin/brcc32.exe'
+        end
+    end
+
+    class GOResourceCompiler < RCResourceCompiler
+        def self.toolName
+            'bin/gorc.exe'
+        end
+    end
+  end
+end

data/lib/rake/delphi/resources.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+require 'erb'
+require 'rake/common/classes'
+require 'rake/delphi/rc'
+require 'rake/helpers/gemversion'
+require 'rake/helpers/rake'
+
+module Rake
+  module Delphi
+    class RCTemplate
+        attr_reader :language, :sublanguage, :lang, :codepage, :filetype
+        alias :method_missing_base :method_missing
+
+        def initialize(owner)
+            @owner = owner
+            # English
+            @language = '0x19'
+            @sublanguage = '0x01'
+            # Russian
+            @lang = '0419'
+            # Russian
+            @codepage = '04E3'
+            # exe
+            @filetype = '0x1'
+            @versioninfo = nil
+            @extra = {}
+            @main_owner_task_name = @owner.name.gsub(/:rc:template$/, '')
+            @main_owner_task = nil
+        end
+
+        def get_binding
+            binding
+        end
+
+        def main_owner_task
+            @main_owner_task ||= @owner.application[@main_owner_task_name]
+        end
+
+        def mainicon
+            # take dcc33 task
+            icon = main_owner_task.mainicon
+        end
+
+        def version
+            Gem::VersionImproved.new(@extra[:version])
+        end
+
+        def versioninfo
+            @versioninfo ||= main_owner_task.versionInfoClass.new(main_owner_task)
+        end
+
+        def product
+            Gem::VersionImproved.new(self.versioninfo['ProductVersion'])
+        end
+
+        def []=(key, value)
+            @extra[key] = value || ''
+        end
+
+        def method_missing(name, *args, &block)
+            if args.empty? && @extra[name]
+                @extra[name]
+            elsif
+                @source.name
+            end
+        end
+    end
+
+    class RCTemplateTask < Rake::Task
+        def initialize(name, app)
+            super
+            @output = nil
+            @template_file = File.expand_path('../../templates/project.erb', __FILE__)
+            @template_obj = RCTemplate.new(self)
+        end
+
+        def output=(value)
+            @output = value.pathmap('%X.rc')
+        end
+
+        def []=(key, value)
+            @template_obj[key] = value
+        end
+
+        def execute(args=nil)
+            erb = ERB.new(IO.read(@template_file))
+            text = erb.result(@template_obj.get_binding)
+            File.open(@output, 'w') do |f|
+                f.write(text)
+            end
+        end
+    end
+
+    class RCTask < Rake::Task
+        attr_accessor :output, :input
+        def initialize(name, app)
+            super
+            @output = nil
+            @is_rc = false
+        end
+
+        def input=(value)
+            @input = value.pathmap('%X.rc')
+            @output = @input.pathmap('%X.res')
+        end
+
+        def is_rc=(value)
+            @is_rc = ! value.to_s.empty?
+        end
+
+        def execute(args=nil)
+            v, path, tool = RCResourceCompiler.find(true)
+            a = []
+            a << '/dRC' if @is_rc
+            a |= ['/fo', Rake.quotepath('', output), '/r', Rake.quotepath('', input) ]
+            opts = { :args => a }
+            opts.merge!(args)
+            cmd = ([Rake.quotepath('', tool)] | opts[:args]).join(' ')
+            RakeFileUtils.verbose(trace?) do
+                sh cmd
+            end
+        end
+    end
+  end
+end