delphi-compiler 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9556a4463bec6d1ee6c5839ead76790799b128e2
+  data.tar.gz: e49d2ee30f20f5f81f589f543308ae446b2adbb6
+SHA512:
+  metadata.gz: 61284f6d39e3399e67fdc78e8b30640f4ef2bc48dbf6dd05393d90776c55b8426dbedb59c1aaa9dfb776f8228b707ab0668218e41166560ff9414df346c1290c
+  data.tar.gz: af4562c2008043379b0fa144a01454cb1feeb74f4309597a564949a4522518164079583795a6fbd7ffff52f1871a656111f7c24dfc5947ec85950011726e4b7e

data/delphi-compiler.gemspec

@@ -0,0 +1,36 @@
+require './version'
+
+Gem::Specification.new do |s|
+  s.name        = 'delphi-compiler'
+  s.version     = VERSION
+  s.date        = '2013-12-04'
+  s.summary     = 'Delphi Compiler'
+  s.description = 'A framework to compile Delphi applications from Rake'
+  s.authors     = ['Scott Sedgwick']
+  s.email       = 'scott.sedgwick@gmail.com'
+  s.files       = [
+    'delphi-compiler.gemspec',
+    'rakefile.rb',
+    'version.rb',
+    'lib/delphi.rb',
+    'lib/delphi/compiler.rb',
+    'lib/delphi/dsl.rb',
+    'lib/delphi/environment.rb',
+    'lib/delphi/groupproj.rb',
+    'lib/delphi/project.rb',
+    'lib/delphi/resource.rb',
+    'lib/delphi/versions.rb',
+    'test/MyClass.pas',
+    'test/test.dproj',
+    'test/test.dpr',
+    'test/test.res',
+    'test/test_project.rb',
+    'test/TestGroup.groupproj',
+    'test/Test/TestMyClass.pas',
+    'test/Test/testTests.dpr',
+    'test/Test/testTests.dproj',
+    'test/Test/testTests.res'
+  ]
+  s.homepage    = 'https://github.com/ScottSedgwick/delphi-compiler'
+  s.license     = 'MIT'
+end

data/lib/delphi.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+require 'delphi/compiler'
+require 'delphi/environment'
+require 'delphi/groupproj'
+require 'delphi/resource'
+require 'delphi/project'
+require 'delphi/versions'
+require 'delphi/dsl'

data/lib/delphi/compiler.rb

@@ -0,0 +1,92 @@
+# encoding: UTF-8
+
+require 'delphi/environment'
+
+module Delphi
+  # Class to execute Delphi compiler
+  #
+  # You should not need to directly interact with this class.
+  # It is accessed via the compile methods of the Project,
+  # GroupProj and Resource classes
+  class Compiler
+    attr_accessor :fail_on_hints_and_warnings, :fail_on_errors
+
+    # You need to pass the Delphi target version to this class.
+    # If you use the Project or GroupProj classes, they will figure
+    # this out for you from the information in the dproj file.
+    def initialize(project_version, fail_on_hints_and_warnings = true)
+      Delphi::Environment.instance.configure(project_version)
+      @fail_on_hints_and_warnings = fail_on_hints_and_warnings
+      @fail_on_errors = true
+    end
+
+    # Compile a Project (dproj file)
+    def compile(dproj, target, config, platform)
+      puts "Compiling #{dproj}"
+      cmd = format(FMT_COMPILE, target, config, platform, dproj)
+      compile_output = `#{cmd}`
+      check_for_failure(compile_output)
+    end
+
+    # Compile a Project Group (groupproj file)
+    def compile_group(groupproj, target)
+      puts "Compiling #{groupproj}"
+      Dir.chdir(File.dirname(groupproj)) do
+        cmd = format(FMT_COMPILE_GROUP, target, File.basename(groupproj))
+        compile_output = `#{cmd}`
+        check_for_failure(compile_output)
+      end
+    end
+
+    # Compile a Resource (rc file)
+    def compile_rc(rcfile)
+      puts "Compiling #{rcfile}"
+      Dir.chdir(File.dirname(rcfile)) do
+        cmd = format(FMT_COMPILE_RC, File.basename(rcfile))
+        `#{cmd}`
+      end
+    end
+
+    def bds
+      File.join(Delphi::Environment.instance.bin_dir, 'bds.exe')
+    end
+
+    private
+
+    FMT_COMPILE = 'msbuild.exe /nologo /t:%s /p:Config=%s;Platform=%s "%s"'
+    FMT_COMPILE_GROUP = 'msbuild.exe /v:q /nologo /t:%s "%s"'
+    FMT_COMPILE_RC = 'brcc32.exe "%s"'
+
+    def check_for_failure(output)
+      if @fail_on_errors && found_errors?(output)
+        puts output
+        fail 'Compilation failed. Errors found.'
+      end
+      if fail_due_to_hints_or_warnings?(output)
+        puts output
+        fail 'Compilation failed. Hints and Warnings found.'
+      end
+      output
+    end
+
+    def fail_due_to_hints_or_warnings?(output)
+      @fail_on_hints_and_warnings && found_hints_or_warnings?(output)
+    end
+
+    def found_hints?(output)
+      output =~ / Hint:/
+    end
+
+    def found_hints_or_warnings?(output)
+      found_hints?(output) || found_warnings?(output)
+    end
+
+    def found_warnings?(output)
+      !(output =~ / 0 Warning\(s\)/)
+    end
+
+    def found_errors?(output)
+      !(output =~ / 0 Error\(s\)/)
+    end
+  end
+end

data/lib/delphi/dsl.rb

@@ -0,0 +1,63 @@
+# encoding: UTF-8
+
+require 'rake/clean'
+require 'delphi/project'
+
+def _parse_args(args)
+  args = (args.take(args.length - 1) + args.last.to_a).flatten if args.last.instance_of?(Hash)
+  sym, dproj, platform, config, prereqs = args[0], args[1], nil, nil, []
+  case args.length
+  when 5
+    platform = args[2]
+    config   = args[3]
+    prereqs  = args[4]
+  when 4
+    platform = args[2]
+    config   = args[3]
+  when 3
+    prereqs  = args[2]
+  end
+  [sym, dproj, platform, config, prereqs]
+end
+
+def delphi(*args)
+  fail '<Symbol> and <Dproj file> are required arguments to the delphi compilation task' if args.length < 2
+  sym, dproj, platform, config, prereqs = _parse_args(args)
+
+  proj = Delphi::Project.new(dproj)
+  proj.platform = platform if platform
+  proj.config = config if config
+  task sym => prereqs do
+    Rake::Task[proj.output].invoke
+  end
+  file proj.output do
+    proj.compile
+    yield proj if block_given?
+  end
+  Rake::Task[sym].sources = proj
+
+  CLOBBER.include(proj.output)
+end
+
+def delphi_exe(sym)
+  Rake::Task[sym].sources.output
+end
+
+def dunit(sym, prereqs)
+  if prereqs.instance_of?(Hash)
+    compile_sym = prereqs.keys[0]
+    prereqs = prereqs[compile_sym]
+  else
+    compile_sym = prereqs
+    prereqs = []
+  end
+  prereqs = [prereqs, compile_sym].flatten
+  task sym => prereqs do
+    exe = delphi_exe(compile_sym)
+    Dir.chdir(File.dirname(exe)) do
+      system(File.basename(exe))
+      fail 'Unit tests failed' unless $CHILD_STATUS.to_i == 0
+      yield if block_given?
+    end
+  end
+end

data/lib/delphi/environment.rb

@@ -0,0 +1,66 @@
+# encoding: UTF-8
+
+require 'singleton'
+require 'win32/registry'
+require 'delphi/versions'
+
+module Delphi
+  # Environment is a Singleton.
+  #
+  # It is responsible for initializing the console environment
+  # for the verison of Delphi that is requested.
+  class Environment
+    include Singleton
+
+    # bin_dir is the location of the Delphi executables
+    attr_reader :bin_dir
+
+    def initialize
+      super
+      @configured_version = 0
+    end
+
+    # Configure needs to be called on the Environment instance before the
+    # Compiler can be used.  Normally it will be done by the Project, which
+    # will read the required version of Delphi from the dproj file.
+    def configure(project_version)
+      return @configured_version if @configured_version == project_version
+      @bin_dir = delphi_directory(project_version)
+      rsvars = File.join(@bin_dir, 'rsvars.bat')
+      load_env(rsvars)
+      @configured_version = project_version
+    end
+
+    private
+
+    def delphi_directory(delphi_version)
+      key = 'SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Embarcadero RAD Studio ' + VERSIONS[delphi_version][:key]
+      begin
+        Win32::Registry::HKEY_LOCAL_MACHINE.open(key) { |reg| "#{reg['InstallLocation']}\\bin" }
+      rescue Win32::Registry::Error
+        puts "Delphi Compiler version #{delphi_version} not installed on this computer"
+      end
+    end
+
+    def load_env(rsvars)
+      File.open(rsvars).each { |line| load_line(line[5..-1]) if line =~ /^@SET / }
+    end
+
+    def load_line(line)
+      key, value = line.split(/\=/)
+      ENV[key] = process_env_var(value)
+    end
+
+    def map_path(path)
+      path.split(';').map { |p| yield(p).chomp }.join(';')
+    end
+
+    def process_env_var(value)
+      map_path(value) { |v| substitute(v.chomp) }
+    end
+
+    def substitute(value)
+      value =~ /^%(.*)%$/ ? ENV[value[1..-2]] : value
+    end
+  end
+end

data/lib/delphi/groupproj.rb

@@ -0,0 +1,87 @@
+# encoding: UTF-8
+
+require 'rexml/document'
+require 'delphi/compiler'
+
+module Delphi
+  # Class to load and compile dproj files
+  #
+  # The RW properties of this class can be changed to modify
+  # the compilation behaviour of a project, but they will not
+  # be saved back to the dproj file - it is read only.
+  class GroupProj
+    attr_accessor :fail_on_hints_and_warnings
+
+    def initialize(filename)
+      @filename = filename
+      fail "#{filename} not found" unless File.exist?(filename)
+
+      load
+      fail "#{filename} is empty" if projects == []
+
+      # Load one project to initialize the environment
+      dproj0 = File.join(File.dirname(filename), projects[0])
+      @p = Delphi::Project.new(dproj0)
+      @fail_on_hints_and_warnings = true
+    end
+
+    # Compile all projects in this group.
+    def compile
+      puts 'Compiling groupproj'
+      compiler.compile_group(@filename, target) if compiler
+    end
+
+    # Reader for the compiler setting
+    def fail_on_errors
+      compiler.fail_on_errors
+    end
+
+    # Setter for the compiler setting
+    def fail_on_errors=(value)
+      compiler.fail_on_errors = value
+    end
+
+    # Reader for the compiler setting
+    def fail_on_hints_and_warnings
+      compiler.fail_on_hints_and_warnings
+    end
+
+    # Setter for the compiler setting
+    def fail_on_hints_and_warnings=(value)
+      compiler.fail_on_hints_and_warnings = value
+    end
+
+    # Returns an array of dproj filenames in this group.
+    def projects
+      path = '/Project/ItemGroup/Projects'
+      result = []
+      @doc.elements.each(path) { |element| result << element.attributes['Include'] }
+      result
+    end
+
+    # Read the current compilation target for this group
+    def target
+      @p.target
+    end
+
+    # Set the compilation target for this group
+    def target=(value)
+      @p.target = value
+    end
+
+    # Returns an array of valid compile targets (Clean, Compile, Build)
+    def targets
+      @p.targets
+    end
+
+    private
+
+    def compiler
+      @p.compiler
+    end
+
+    def load
+      File.open(@filename) { |f| @doc = REXML::Document.new f }
+    end
+  end
+end

data/lib/delphi/project.rb

@@ -0,0 +1,128 @@
+# encoding: UTF-8
+
+require 'rexml/document'
+require 'delphi/compiler'
+
+module Delphi
+  # Class to load and compile dproj files
+  #
+  # The RW properties of this class can be changed to modify
+  # the compilation behaviour of a project, but they will not
+  # be saved back to the dproj file - it is read only.
+  class Project
+    # The configuration to build - e.g. Debug, Release.
+    attr_accessor :config
+    # The platform to build for - e.g. Win32, Win64.
+    attr_accessor :platform
+    # The msbuild target - e.g. Build, Compile, Clean.
+    attr_accessor :target
+
+    attr_reader :dproj
+
+    def initialize(dproj)
+      @dproj = dproj
+      fail "#{dproj} not found" unless File.exist?(dproj)
+
+      load
+      @compiler = Delphi::Compiler.new(project_version)
+      @config = default_config
+      @target = targets[0]
+      @platform = platforms[0]
+      @outputpath = get('//DCC_ExeOutput').text
+    end
+
+    def compile
+      @compiler.compile(@dproj, @target, @config, @platform)
+    end
+
+    # Set the config. Restricts it to valid values.
+    def config=(value)
+      check_value(configs, value, 'config')
+      @config = value
+    end
+
+    def fail_on_hints_and_warnings
+      @compiler.fail_on_hints_and_warnings
+    end
+
+    def fail_on_hints_and_warnings=(value)
+      @compiler.fail_on_hints_and_warnings = value
+    end
+
+    # Returns the set of valid configurations as read from the dproj file
+    def configs
+      result = []
+      @doc.elements.each('/Project/ItemGroup/BuildConfiguration') do |element|
+        config = element.attributes['Include']
+        result << config unless config == 'Base'
+      end
+      result
+    end
+
+    # The output file without the path.
+    def out_file
+      File.basename(@output)
+    end
+
+    def output
+      File.expand_path(File.join(subst_path(@outputpath), File.basename(@dproj, '.dproj') + '.exe'))
+    end
+
+    # Set the platform. Restricts it to valid values.
+    def platform=(value)
+      check_value(platforms, value, 'platform')
+      @platform = value
+    end
+
+    # Returns the set of valid platforms as read from the dproj file
+    def platforms
+      path = '/Project/PropertyGroup/Platform'
+      result = []
+      @doc.elements.each(path) { |element| result << element.text }
+      result
+    end
+
+    def project_version
+      path = 'Project/PropertyGroup/ProjectVersion'
+      @project_version = get(path).text.to_f unless @project_version
+      @project_version
+    end
+
+    # Set the target. Restricts it to valid values.
+    def target=(value)
+      check_value(targets, value, 'target')
+      @target = value
+    end
+
+    # Returns the set of valid targets
+    def targets
+      %w(Build Compile Clean)
+    end
+
+    private
+
+    def check_value(collection, value, name)
+      fail "#{value} is not a valid #{name} for #{@dproj}" unless
+        collection.include?(value)
+    end
+
+    def default_config
+      dc = get('Project/PropertyGroup/Configuration')
+      dc ? dc.text : 'Debug'
+    end
+
+    def get(path)
+      REXML::XPath.first(@doc, path)
+    end
+
+    def load
+      File.open(@dproj) { |f| @doc = REXML::Document.new f }
+    end
+
+    def subst_path(path)
+      result = path.sub('$(Platform)', platform).sub('$(Config)', config)
+      result = File.join(File.dirname(dproj), result) if result.start_with?('.')
+      File.expand_path(result)
+    end
+  end
+end