rake-delphi 0.0.4

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rake-delphi.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Alexey Shumkin
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Rake::Delphi
+
+This gem adds an ability to compile automatically Delphi projects
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rake-delphi'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rake-delphi
+
+## Usage
+
+    
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new('test') do |t|
+    t.ruby_opts << '-d' if Rake.application.options.trace
+    t.libs << 'test'
+    t.verbose = true
+end

data/lib/rake/common/chdirtask.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'rake/common/classes'
+
+module Rake
+  module Delphi
+    class ChDir < BasicTask
+        def initialize(task, dir)
+            super(task)
+            return unless block_given?
+            od = Dir.pwd
+            begin
+                Dir.chdir(dir)
+                yield dir
+            ensure
+                Dir.chdir(od)
+            end
+        end
+    end
+  end
+end

data/lib/rake/common/classes.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Rake
+  module Delphi
+    class BasicTask
+        def initialize(task)
+            @task = task
+        end
+
+        def trace?
+            @task.application.options.trace || $DEBUG || false
+        end
+    end
+  end
+end

data/lib/rake/common/dsl.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+# include this file
+# to avoid errors like 'uninitialized constant Rake::DSL'
+# on rake > v0.8.7
+if RAKEVERSION !~ /^0\.8/
+    require 'rake/dsl_definition'
+    include Rake::DSL
+    Rake::TaskManager.record_task_metadata = true if Rake::TaskManager.respond_to?('record_task_metadata')
+end

data/lib/rake/common/echotask.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'fileutils'
+require 'rake/common/classes'
+require 'rake/helpers/raketask'
+
+module Rake
+  module Delphi
+    class EchoToFile < BasicTask
+        def initialize(task, ifile, ofile, vars)
+            super(task)
+            @task.out "#{ifile} -> #{ofile}"
+            FileUtils.mkdir_p(File.dirname(ofile))
+            File.open(ifile, 'r') do |f|
+                File.open(ofile, 'w') do |w|
+                    while (line = f.gets)
+                        # replace ${var1.var2.var3} with its value from xml
+                        line.gsub!(/\$\{(.+?)\}/) do |match|
+                            val = nil
+                            $1.split(".").each do |part|
+                                val = val.nil? ? vars[part] : val[part]
+                            end
+                            match = val.nil? ? match : val
+                        end if vars
+                        w.puts line
+                    end
+                    w.close
+                end
+                f.close
+            end
+        end
+    end
+  end
+end

data/lib/rake/common/exectask.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'rake/common/classes'
+
+module Rake
+  module Delphi
+
+    class CustomExec < BasicTask
+    public
+        def execute
+        end
+
+        def to_system_path(path, base = '')
+            r = super(path, base)
+            # quote path if it contains SPACE
+            r = '"%s"' % r.strip if r[" "]
+        end
+    end
+  end
+end

data/lib/rake/common/git.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+require 'rake/common/classes'
+require 'rake/helpers/rake'
+
+module Rake
+  module Delphi
+    class Git
+        def self.version
+            null = Rake.cygwin? ? '/dev/null' : 'nul'
+            r = `git rev-parse 1>#{null} 2>&1 && git describe --abbrev=1 2>#{null}`
+            # trim
+            r.chomp!
+            unless r.to_s.empty?
+                # add ".0" for exact version (like v3.0.43)
+                # example: v3.0.43-5-g3952dc
+                # take text before '-g'
+                r << '.0'
+                r = r.split('-g')[0]
+                # remove any non-digits in the beginning
+                # remove any alpha-characters
+                r.gsub!(/^\D+|[a-zA-Z]+/, '')
+                # replace any non-digits with dots
+                r.gsub!(/\D/, '.')
+            end
+        end
+    end
+
+    class GitChangelog < BasicTask
+
+        attr_reader :opts, :changelog, :processed
+
+        def initialize(task, opts)
+            super(task)
+            @opts = {:filter => '.'}
+            @opts.merge!(opts) if opts.kind_of?(Hash)
+            @changelog = @processed = []
+            get_changelog
+            yield self if block_given?
+        end
+
+    def processed_string
+        @processed.join("\n")
+    end
+
+    def changelog_string
+        @changelog.join("\n")
+    end
+
+    private
+        def get_changelog
+            cmd = ['git']
+            cmd << "-c i18n.logOutputEncoding=#{opts[:logoutputencoding]}" if opts[:logoutputencoding]
+            cmd << 'log' << '--format=%B' << "#{opts[:since]}..HEAD"
+            p cmd if trace?
+            @changelog=%x[#{cmd.join(' ')}].lines.to_a
+            @changelog.map! do |line|
+                line.chomp!
+                if line.respond_to?(:force_encoding) \
+                        && opts[:logoutputencoding]
+                    line.force_encoding(opts[:logoutputencoding])
+                end
+                line
+            end
+
+            # delete empty lines
+            @changelog.delete_if { |line| line.chomp.empty? }
+            # unique lines only
+            @changelog.uniq!
+            do_filter
+            do_process
+            puts @changelog if trace?
+        end
+
+        def charset
+            opts[:logoutputencoding]
+        end
+
+        def do_filter
+            @filter = Regexp.new(@opts[:filter])
+            @changelog.delete_if { |line| ! @filter.match(line) }
+        end
+
+        def do_process
+            @processed = []
+            return unless @opts[:process] && @opts[:process].size > 0
+            @processed = @changelog.map do |line|
+                line = line.dup
+                process = @opts[:process]
+                process = [process] unless process.kind_of?(Array)
+                process.each do |filters|
+                    raise "`%s` must be a Hash" % [filters] unless filters.kind_of?(Hash)
+                    filters.each do |filter, subst|
+                        line.gsub!(filter, subst)
+                    end
+                end
+                line
+            end
+        end
+    end
+  end
+end

data/lib/rake/common/hashtask.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'rake/common/classes'
+require 'rake/helpers/digest'
+
+module Rake
+  module Delphi
+    class HashTask < BasicTask
+        def initialize(file, alg)
+            @file = file
+            @alg = alg
+        end
+
+        def digest
+            if ['md5', 'sha1'].include?(@alg)
+                require 'digest/' + @alg
+                return eval("Digest::#{@alg.upcase}.file(@file).hexdigest.upcase")
+            else
+                return "%02X" % Digest::CRC32.file(@file).digest.to_i
+            end
+        end
+    end
+
+    class HashesTask < BasicTask
+        def initialize(task, files, alg)
+            super(task)
+            @hashes = {}
+            calc_hashes(files, alg)
+        end
+
+        def calc_hashes(files, alg)
+            files = [files] unless files.kind_of?(Array)
+            files.each do |f|
+                @hashes[f] = { alg.upcase => HashTask.new(f, alg).digest }
+            end
+        end
+
+        def to_hash
+            @hashes
+        end
+    end
+  end
+end

data/lib/rake/common/initask.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'inifile'
+require 'rake/common/classes'
+
+module Rake
+  module Delphi
+    class IniProperty < BasicTask
+    private
+        def self.parse(string)
+            dir = File.dirname(string)
+            file, section, valuename = string.gsub(dir, '').split(":")
+            file = dir + '/' + File.basename(file)
+            return file, section, valuename
+        end
+    public
+        def self.get(string)
+            file, section, valuename = parse(string)
+            ini = IniFile.load(file)
+            return ini[section][valuename]
+        end
+
+        def self.set(string, value)
+            file, section, valuename = parse(string)
+            ini = IniFile.load(file)
+            ini[section][valuename] = value
+            ini.write
+        end
+    end
+  end
+end

data/lib/rake/common/libstask.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'rake/common/classes'
+require 'rake/delphi/liblist'
+
+module Rake
+  module Delphi
+    class LibsTask < Rake::Task
+        attr_reader :libs
+
+        def initialize(name, app)
+            super
+            @original_dir = ENV['RAKE_DIR'] || Rake.original_dir
+        end
+
+        def self.define(name, app)
+            app.tasks.each do |t|
+                # if there is a task with a name like a searched one
+                return t if t.name.index(name)
+            end
+            # else - define a new task
+            app.define_task(LibsTask, name)
+        end
+
+        def libs_relative(level)
+            @libs.map { |d| d.gsub(@original_dir, '.' + '/..' * level)}
+        end
+
+        def execute(args = nil)
+            mask = @original_dir + '/lib/**/**'
+            @libs = LibList.new(mask)
+        end
+    end
+  end
+end

data/lib/rake/common/sendmailtask.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'rake/common/classes'
+require 'rake/helpers/rake'
+
+module Rake
+  module Delphi
+    class Sendmail < BasicTask
+
+        def initialize(task, opts)
+            super(task)
+            cmd = ''
+            predefined = { :from => '-f', :"from.full" => '-F', :extra => nil, :to => nil }
+            predefined.keys.sort{|a, b| a.to_s <=> b.to_s}.each do |k|
+                cmd += "#{predefined[k]} #{opts[k]} " if opts[k]
+            end
+            cmd = "#{sendmail} -i #{cmd}"
+            pp cmd if trace?
+            if @task.application.windows? && Rake.ruby18?
+                require 'win32/open3'
+            else
+                require 'open3'
+            end
+            Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thr|
+                stdin.puts(opts[:text])
+                stdin.close
+                while s = stdout.gets
+                    puts s
+                end
+                while s = stderr.gets
+                    puts s
+                end
+            end
+        end
+
+        def sendmail
+            if @task.application.unix?
+                "sendmail"
+            else
+                ENV['SENDMAIL']
+            end
+        end
+    end
+  end
+end

data/lib/rake/common/ziptask.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+require 'zlib'
+require 'rake/common/classes'
+require 'rake/helpers/raketask'
+
+module Rake
+  module Delphi
+    class GZip < BasicTask
+        def initialize(task, params)
+            super(task)
+            if params.kind_of?(String)
+                gzip_file(params)
+            elsif params.kind_of?(Array)
+                params.each do |file|
+                    gzip_file(file)
+                end
+            end
+        end
+
+    private
+        def gzip_file(file)
+            @task.out "GZip #{file} -> #{file}.gz"
+            sfile = File.open(file + '.gz', "w+b")
+            gzfile = Zlib::GzipWriter.wrap(sfile) do |gz|
+                File.open(file, "rb") do |f|
+                    gz.mtime = File.mtime(file)
+                    gz.orig_name = File.basename(file)
+                    gz.write(f.read)
+                    gz.close
+                end
+            end
+        end
+    end
+
+    class ZipTask < BasicTask
+        def initialize(task, zipfile, files, options = nil)
+            super(task)
+            pp [zipfile, files] if trace?
+            raise "zipfile name is not defined!" if zipfile.nil? || zipfile.empty?
+            @norubyzip = nil
+            @options = options || {}
+            begin
+                require 'zipruby'
+            rescue LoadError
+                begin
+                    require 'zip/zip'
+                rescue LoadError
+                    @norubyzip = true
+                end
+            end
+            raise "no ZIP library (nor zipruby nor rubyzip) found!" if @norubyzip
+            if defined? Zip::Archive
+                # zipruby used
+                $stderr.puts '`zipruby` gem is used' if trace?
+                Zip::Archive.open(zipfile, Zip::CREATE | Zip::TRUNC) do |z|
+                    files.each do |f|
+                        zip_addfile(z, f)
+                    end
+                end
+            else
+                # work with rubyzip
+                $stderr.puts '`rubyzip` gem is used' if trace?
+                File.unlink(zipfile) if File.exists?(zipfile)
+                Zip.options[:continue_on_exists_proc] = true
+                Zip::ZipFile.open(zipfile, Zip::ZipFile::CREATE) do |z|
+                    files.each do |f|
+                        zip_addfile(z, f)
+                    end
+                end
+            end
+        end
+
+    private
+        def zip_addfile(zipfile, file)
+            return if ! File.exists?(file)
+            filename = File.basename(file)
+            @task.out "Zipping #{file}..."
+            if defined? Zip::Archive
+                if @options[:preserve_paths]
+                    if ! zipfile.locate_name(File.dirname(file))
+                        zipfile.add_dir(File.dirname(file))
+                    end
+                    filename = file
+                end
+                zipfile.add_file(filename, file)
+            else
+                if @options[:preserve_paths]
+                    dir = File.dirname(file)
+                    # avoid "./<filename>" entries (instead of "<filename>")
+                    filename = File.join(dir, filename) if dir != '.'
+                end
+                zipfile.add(filename, file)
+            end
+        end
+    end
+  end
+end