sixarma-bt 0.7.1

data/lib/sixarma/bt.rb

@@ -0,0 +1,635 @@
+=begin
+  6thSense.eu ArmA BuildTools (Automation Suite), by Sickboy (sb_at_6thSense.eu)
+
+  # TODO: Tweak / Clean / Merge / Split / Optimize
+  # TODO: log4r support per module instead of all in core?
+  # TODO: Implement FATAL, WARN etc loglevels?
+  # TODO: Convert all Config/Stats classes from CON_STANT to ConStant variation
+  # TODO: List:
+  - More sophisticated svn changes system which goes beyond "Addons" and "Dta" etc
+  -- CONFIG_MOD_SUBFOLDERS per mod implemented, but only active for creating addons and signing
+  - Think about how to resolve "Case sensitivity for paths", or should we not at all?
+  - Finish implementation of Time.now and processed time
+  - SVN Update/Commit Functions
+=end
+
+# load core modules
+require 'rubygems'
+
+gem 'sixcore'
+require 'sixcore'
+require 'sixcore/ftp'
+require 'sixcore/nsis'
+require 'sixcore/svn'
+
+gem 'sixarma'
+require 'sixarma'
+require 'sixarma/pbotools'
+require 'sixarma/sign'
+
+# load program modules
+require 'sixarma/bt/build'
+require 'sixarma/bt/nsis'
+require 'sixarma/bt/svn'
+require 'sixarma/bt/sign'
+
+# Main ArmA Module
+module SixArma
+  # Build Tools Module
+  module Bt
+    # Main Config Structure
+    CONFIG = Struct.new(:title, :titlelong, :outroot, :verpath, :veraddon, :changelog, :workdir, :workbin, :workpbo, :work3rd, :work3rd_pbo,
+      :workdel, :listbin, :listpbo, :list3rd_pbo, :sign, :nsis, :ftp, :mods)
+    # Main FTP Config Structure
+    CONFIG_FTP = Struct.new(:host, :user, :pass, :pathfull, :pathupdate)
+    # Main NSIS Config Structure
+    CONFIG_NSIS = Struct.new(:out, :template, :output, :reg_newver, :reg_oldver, :reg_delete, :reg_type, :reg_verpath, :reg_out)
+    # Main Signature Config Structure
+    CONFIG_SIGN = Struct.new(:file, :keytype)
+
+    # Main Mod Config Structure
+    CONFIG_MOD = Struct.new(:changes, :lists, :path, :source, :altsource, :destination, :subfolders, :svn, :nsis)
+    # Mod Subfolders Config Structure
+    CONFIG_MOD_SUBFOLDERS = Struct.new(:name, :type)
+    # Mod NSIS Config Structure
+    CONFIG_MOD_NSIS = Struct.new(:out)
+    # Mod SVN Config Structure
+    CONFIG_MOD_SVN = Struct.new(:url, :user, :pass)
+
+    # Main Stats Structure
+    STATS = Struct.new(:released, :oldver, :newver, :updatefile, :fullfile, :mods)
+    # Main Mod Stats Structure
+    STATS_MOD = Struct.new(:oldrev, :newrev, :subfolders, :changelog)
+    # Mod Subfolders Structure
+    STATS_MOD_SUBFOLDERS = Struct.new(:add, :change, :del)
+    # Changelog Structure
+    STATS_MOD_CHANGELOG = Struct.new(:added, :updated, :removed, :changed, :fixed, :local)
+
+    # Main Program Class
+    class Builder
+      COMPONENT = 'SixArma::Bt::Builder'
+
+      attr_reader(:config, :stats)
+      attr_accessor :threads
+
+      # yaml:: Yaml configuration file
+      # halt:: Wait for user input every step?
+      def initialize(yaml, halt)
+        SixCore::info "Start Time: #{Time.now}"
+
+        @halt = halt
+        @threads = []
+        @stats = STATS.new()
+        if FileTest.exist?(yaml)
+          SixCore::info "Reading From Configuration File: #{yaml}"
+          File.open(yaml) { |yf| @config = YAML::load( yf ) }
+        else
+          SixCore::info "Yaml file not found (#{yaml})"
+          Process.exit
+        end
+        read_stats()
+      end
+
+      private
+      # Updates files from source to destination
+      # source:: Source path
+      # destination:: Destination path
+      def update_all(source, destination)
+        SixCore::infos("Update_All", COMPONENT) # TODO
+        SixCore::info "Updating *all* files - source: #{source} - destination: #{destination}..."
+        SixCore::fileupdate(
+          "#{@config.outroot}\\files\\#{source}\\",
+          "#{@config.outroot}\\files\\#{destination}\\"
+        )
+      end
+
+      # Updates signature files from source to destination
+      # source:: Source path
+      # destination:: Destination path
+      def update_sign(source, destination)
+        SixCore::infos("Update_Sign", COMPONENT) # TODO
+        SixCore::info "Updating *sign* files - source: #{source} - destination: #{destination}..."
+        SixCore::fileupdate(
+          "#{@config.outroot}\\files\\#{source}\\",
+          "#{@config.outroot}\\files\\#{destination}\\",
+          "/IF *.bisign *.bikey"
+        )
+      end
+
+      # Uploads with raw parameters
+      # host:: FTP Hostname
+      # user:: FTP Username
+      # pass:: FTP Password
+      # path:: FTP Path
+      # localpath:: Local Path
+      # put:: File to upload
+      # tmp:: Leave file as filename_tmp on ftp when finished?
+      def upload_raw(host, user, pass, path, localpath, put, tmp = true)
+        ftp = SixCore::Ftp.new(host, user, pass)
+        ftp.put(put, localpath, path, true, tmp)
+        ftp.ftp.close
+      end
+
+      public
+      # Upload file
+      # put:: File to upload
+      # type:: Type (update or full)
+      def upload(put, type, tmp = true)
+        SixCore::infos("Upload", COMPONENT)
+        @config.ftp.each do |f|
+          path = eval "f.path#{type}"
+          SixCore::info "Uploading #{put} to #{f.host}/#{path}..."
+          ftp = SixCore::Ftp.new(f.host, f.user, f.pass)
+          ftp.put(put, "#{@config.outroot}\\", path, true, tmp)
+          ftp.ftp.close
+        end
+        SixCore::info "Uploading #{put} finished!"
+        SixCore::halt() if @halt
+      end
+
+      # Uploads in seperate thread
+      # type:: String, update or full
+      def upload_thread(type)
+        name = eval("@stats.#{type}file")
+        tmp = []
+        @config.ftp.each do |f|
+          tmp << [f.host, f.user, f.pass, eval("f.path#{type}"), "#{@config.outroot}\\", name]
+        end
+        @threads << Thread.new(tmp,name) do |ftps,name|
+          SixCore::infos("Upload", COMPONENT)
+          SixCore::info "Uploading #{name}..."
+          ftps.each { |f| upload_raw(*f) }
+          SixCore::info "Uploading #{name} finished..."
+        end
+      end
+
+      # Releases uploaded update/full setup files
+      def release()
+        SixCore::info "Releasing #{@stats.newver}..."
+        @config.ftp.each do |f|
+          begin
+            raise 'Error' if @stats.fullfile.nil? && @stats.updatefile.nil?
+            ftp = SixCore::Ftp.new(f.host, f.user, f.pass)
+            ftp.rename("#{@stats.fullfile}_tmp", @stats.fullfile, f.pathfull) unless @stats.fullfile.nil?
+            ftp.rename("#{@stats.updatefile}_tmp", @stats.updatefile, f.pathupdate) unless @stats.updatefile.nil?
+            ftp.ftp.close
+          rescue
+            # TODO: Evaluate direct log
+            SixCore::log.fatal 'Renaming files on FTP; Something went wrong, please verify!'
+            Process.exit
+          ensure
+            ftp.ftp.close unless ftp.nil?
+          end
+        end
+        @stats.released = true
+        SixCore::info "Version Info: #{@stats.newver} Released!"
+
+        write_stats()
+      end
+
+      # Reads stats from yaml version file
+      def read_stats()
+        # TODO: Prettify
+        dir = Dir.open("#{@config.outroot}/versions").entries
+        if dir.size > 2
+          dir.reverse!
+          File.open("#{@config.outroot}/versions/#{dir[0]}") do |yf|
+            SixCore::info "Reading From Stats File: #{dir[0]}"
+            stats = YAML::load(yf)
+            if stats.released
+              SixCore::info "Previous version was released; New Version"
+              @stats = STATS.new()
+              @stats.mods = []
+              @stats.oldver = stats.newver.to_s
+              @stats.newver = @stats.oldver.to_f + 0.01
+              @stats.newver = @stats.newver.to_s
+              # TODO: Prettify??
+              @stats.newver << "0" # always append extra 0 due to floating point 0.50 --> 0.5
+              @stats.oldver << "0" # always append extra 0 due to floating point 0.50 --> 0.5
+              @stats.newver = /(.)\.(.)(.)/.match(@stats.newver).to_s
+              @stats.oldver = /(.)\.(.)(.)/.match(@stats.oldver).to_s
+
+              @stats.released = false
+              stats.mods.each do |mod|
+                modstats = STATS_MOD.new()
+                modstats.subfolders = []
+                mod.subfolders.each do
+                  sf = STATS_MOD_SUBFOLDERS.new()
+                  sf.add = []
+                  sf.del = []
+                  sf.change = []
+                  modstats.subfolders << sf
+                end
+                modstats.oldrev = mod.newrev
+                @stats.mods << modstats
+              end
+            else
+              SixCore::info "Previous version wasn't released; Sticking to current version"
+              @stats = stats
+            end
+          end
+        else
+          info "No version yaml found in versions folder, aborting"
+          Process.exit
+        end
+
+        SixCore::info "Current Version: #{@stats.newver} | Previous Version: #{@stats.oldver}"
+
+        # update the version files
+        SixCore::info "Updating version.txt..."
+        # used by updater setup program
+        File.open("#{@config.outroot}/files/update/#{@config.mods[0].destination}/#{@config.verpath}/version.txt", "w") do |f|
+          f << @stats.newver
+        end
+
+        # used ingame
+        unless @config.veraddon.nil?
+          verfile = File.open(
+            "#{@config.mods[0].path}/#{@config.mods[0].source}/Addons/#{@config.veraddon}/version.hpp",
+            "w") do |f|
+            f.puts "VERSION = \"#{@stats.newver}\";"
+            f.puts "text = \"#{@config.title} v#{@stats.newver}\";"
+          end
+        end
+
+        @names = []
+        @names_c = []
+
+        #tmp
+
+        read_changelog()
+        # Write per mod per version changelog
+        write_changelog()
+
+        # Write Stats
+        write_stats()
+
+        # Write all in one changelog all versions and mods
+        write_changelog2()
+        SixCore::infos 'Latest Commits by:'
+        @names.each_with_index do |n, idx|
+          SixCore::info "#{n}: #{@names_c[idx]} commits"
+        end
+      end
+
+      # Experimental: "Replay SVN Log and Reimport"
+      def tmp
+        Dir.chdir("#{@config.outroot}/versions")
+
+        Dir.glob("*.yaml") do |f|
+          File.open("#{@config.outroot}/versions/#{f}") do |yf|
+            SixCore::info "Reading From Stats File: #{f}"
+            @stats = YAML::load(yf)
+            read_changelog(false)
+            write_stats()
+          end
+        end
+      end
+
+      def read_changelog(readrev = true)
+        @stats.mods.each_with_index do |mod, idx|
+          mod.changelog = STATS_MOD_CHANGELOG.new()
+          mod.changelog.changed = []
+          mod.changelog.removed = []
+          mod.changelog.fixed = []
+          mod.changelog.added = []
+          mod.changelog.updated = []
+          mod.changelog.local = []
+          mod2 = @config.mods[idx]
+          unless mod2.svn.nil?
+            svn = SixCore::Svn.new("#{mod2.path}#{mod2.source}", mod2.svn.user, mod2.svn.pass)
+            mod.newrev = svn.read_rev() if readrev
+            unless mod.oldrev == mod.newrev
+              log_orig = svn.log_split(mod.oldrev.to_i + 1, mod.newrev)
+              log_orig.each do |l|
+                if l[1].size > 0
+                  # TODO Pretify
+                  name = l[0][1]
+                  replace = [['ace_dev_', ''], ['ace_support_', ''], ['wgl_support_', ''], ['wgl_dev_', ''], ['wgl_supporter_', '']]
+                  name = SixCore::gsub_ar(name, replace)
+                  name.capitalize!
+                  if @names.include?(name)
+                    @names.each_with_index do |n, idx|
+                      if n == name
+                        @names_c[idx] = @names_c[idx] + 1
+                      end
+                    end
+                  else
+                    @names_c << 1
+                    @names << name
+                  end
+                  l[1].each do |c|
+                    case c
+                    when /^[\s]*~[\s]*/
+                      c.gsub!(/^[\s]*~[\s]*/, '')
+                      c.strip!
+                      c.gsub!(/[\s]+/, '')
+                      type = c[/^([\w]+)/]
+                      type.upcase! unless type.nil?
+                      if ["CHANGED", "FIXED", "ADDED", "REMOVED", "UPDATED", "LOCAL",
+                          "MOVED", "MODIFIED", "RENAMED", "REVERTED", "UPDATE",
+                          "ADD", "MOD", "FIX", "MOV", "UPD", "DEL",
+                          "C", "A", "R", "F"].include?(type)
+                        c.gsub!(/^([\w]+)[\s]*/, "")
+                        case c
+                        when /^-* *([\w]+):/ # /^- ([\w]+):/  and  /^([\w]+):/
+                          tmp = c[/^-* *([\w]+):/]
+                        when /^- +([\w]+) +\-/
+                          tmp = c[/^- +([\w]+) +\-/]
+                        when /^- ([\w]+) ([\w]+):/
+                          tmp = c[/^- ([\w]+) ([\w]+):/]
+                        when /^- ([\w]+) ([\w]+) ([\w]+):/
+                          tmp = c[/^- ([\w]+) ([\w]+) ([\w]+):/]
+                        end
+
+                        unless tmp.nil?
+                          c.gsub!(tmp, "")
+                          c.strip!
+                          tmp.gsub!(/[:-]/, "")
+                          tmp.gsub!(/[\s]*-[\s]*/, "")
+                          tmp.strip!
+                          c = "#{c} - #{tmp}"
+                        end
+                        c.gsub!(/^: /, "")
+                        c.gsub!(/^- /, "")
+                      else
+                        type = "CHANGED"
+                      end
+                      unless c.empty?
+                        case c
+                        when /version tag/i, /buildscripts/i, /build /i, /readme /i, /credits/i, /\.txt/i, /\.bat/i, /changelog/i, / txt /i, /this/i
+                          type = "LOCAL"
+                        end
+                        # Only capitalize first word, leave rest intact
+                        c.strip!
+                        c.gsub!(/^[:\-\.~]\s*/, '')
+                        # Filter :-D
+                        c.gsub!(/penis|dildo|noob/i, '****')
+                        f = c[/^[\w]+/]
+                        unless f.nil?
+                          case f
+                          when /REMOVED/i, /DELETED/i
+                            type = "REMOVED"
+                            c.sub!(f, "")
+                            c.gsub!(/^[:\-\.~]/, '')
+                          when /TODO/i, /RESTORED/i
+                            type = "LOCAL"
+                          end
+                        end
+                        c.strip!
+                        f = c[/^[\w]+/]
+                        c.gsub!(/^[\w]+/, "")
+                        unless f.nil?
+                          f.strip!
+                          f.capitalize!
+                        end
+                        entry = "#{f}#{c} [#{name}]"
+                        entry.strip!
+                        unless "#{f}#{c}".strip.empty?
+                          # Add entry to appriopriate array
+                          case type
+                          when "CHANGED", "C", "MODIFIED", "MOD", "RENAMED"
+                            mod.changelog.changed << entry
+                          when "ADDED", "A", "ADD"
+                            mod.changelog.added << entry
+                          when "REMOVED", "R", "DEL"
+                            mod.changelog.removed << entry
+                          when "UPDATED", "U", "UPD", "UPDATE"
+                            mod.changelog.updated << entry
+                          when "FIXED", "F", "FIX"
+                            mod.changelog.fixed << entry
+                          when "LOCAL", "MOVED", "MOV", "REVERTED"
+                            mod.changelog.local << entry
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+            mod.changelog.changed.uniq!
+            mod.changelog.added.uniq!
+            mod.changelog.removed.uniq!
+            mod.changelog.updated.uniq!
+            mod.changelog.fixed.uniq!
+            mod.changelog.local.uniq!
+            SixCore::info "SVN #{mod2.destination} Current Rev: #{mod.newrev} | Previous Rev: #{mod.oldrev}"
+          end
+        end
+      end
+
+      # Writes stats to yaml version file
+      def write_stats()
+        SixCore::debugs("Writing Version Stats", COMPONENT)
+        SixCore::debug "Current Ver: #{@stats.newver}"
+
+        File.open("#{@config.outroot}/versions/_version_#{@stats.newver}.yaml", 'w' ) do |out|
+          YAML.dump( @stats, out )
+        end
+      end
+
+
+      def gen_clog()
+        log = []
+        Dir.chdir("#{@config.outroot}/versions")
+        ar = []
+        Dir.glob("*.yaml") do |f|
+          ar << f
+        end
+        ar.reverse!
+        SixCore::info "Replaying logfiles from Stats Files: #{ar.first} - #{ar.last}"
+        ar.each do |f|
+          File.open("#{@config.outroot}/versions/#{f}") do |yf|
+            stats = YAML::load(yf)
+            log << ''
+            log << "== v#{stats.newver} =="
+            stats.mods.each_with_index do |mod, idx|
+              mod2 = @config.mods[idx]
+              unless mod2.svn.nil?
+                nl = generate_log(mod)
+                unless nl.empty?
+                  log << "* #{mod2.destination }, Revision: #{mod.newrev} - #{mod.oldrev}"
+                  log << nl
+                end
+              end
+            end
+          end
+        end
+        return log
+      end
+
+      # Generates log from svn comments
+      # mod:: Object, Mod object
+      def generate_log(mod)
+        log = []
+        unless mod.oldrev == mod.newrev
+          if mod.changelog.added.size > 0
+            log << "** ADDED:"
+            mod.changelog.added.sort!
+            mod.changelog.added.each do |e|
+              e = "*** #{e}"
+              log << e
+            end
+            log << ''
+          end
+          if mod.changelog.updated.size > 0
+            log << "** UPDATED:"
+            mod.changelog.updated.sort!
+            mod.changelog.updated.each do |e|
+              e = "*** #{e}"
+              log << e
+            end
+            log << ''
+          end
+          if mod.changelog.removed.size > 0
+            log << "** REMOVED:"
+            mod.changelog.removed.sort!
+            mod.changelog.removed.each do |e|
+              e = "*** #{e}"
+              log << e
+            end
+            log << ''
+          end
+          if mod.changelog.changed.size > 0
+            log << "** CHANGED:"
+            mod.changelog.changed.sort!
+            mod.changelog.changed.each do |e|
+              e = "*** #{e}"
+              log << e
+            end
+            log << ''
+          end
+          if mod.changelog.fixed.size > 0
+            log << "** FIXED:"
+            mod.changelog.fixed.sort!
+            mod.changelog.fixed.each do |e|
+              e = "*** #{e}"
+              log << e
+            end
+            log << ''
+          end
+        end
+        return log
+      end
+
+      # Formats and writes changelog for all versions
+      def write_changelog2()
+        lf = File.new("#{@config.outroot}/files/update/#{@config.mods[0].destination}/Docs/changelog.txt", 'w')
+        lf.puts '= Changelog ='
+        #dir.reverse!
+        log = gen_clog()
+        if log.size > 0
+          SixCore::info 'Writing Changelog'
+          log.each do |l|
+            lf.puts(l)
+          end
+        end
+        Dir.chdir(SixCore::MAINDIR)
+        lf.close
+      end
+
+      # Formats and writes changelog for current version
+      def write_changelog()
+        @stats.mods.each_with_index do |mod, idx|
+          mod2 = @config.mods[idx]
+          unless mod2.svn.nil?
+            lf = File.new("#{@config.mods[idx].changes}/changelog.txt", 'w')
+            lf.puts "* #{mod2.destination} v#{@stats.newver}, Revision: #{mod.newrev} - #{mod.oldrev}"
+            log = generate_log(mod)
+            if log.size > 0
+              log.each do |l|
+                lf.puts(l)
+              end
+            end
+            lf.close
+          end
+        end
+      end
+
+      # Builds Update
+      # svn_do, addon_changes, sign_update
+      def build_update()
+        svn_do()
+        addon_changes()
+        sign_update()
+      end
+
+      # Builds Full
+      # svn_do, clear, addon_changes, update_all("update", "full"), sign_full
+      def build_full()
+        svn_do()
+        clear()
+        addon_changes()
+        update_all("update", "full")
+        sign_full()
+      end
+
+      # Creates Update
+      # build_full, update_sign("full", "update"), nsis_update
+      def create_update()
+        build_full()
+        update_sign("full", "update")
+        nsis_update()
+      end
+
+      # Creates Full
+      # build_full, nsis_full
+      def create_full()
+        build_full()
+        nsis_full()
+      end
+
+      # Creates Update and Full
+      # create_update, nsis_full
+      def create_all()
+        create_update()
+        nsis_full()
+      end
+
+      # Distributes Update
+      # thread:: Boolean: Uses seperate thread when set to true
+      def dist_update(thread = false)
+        if thread
+          upload_thread("update")
+        else
+          upload(@stats.updatefile, "update")
+        end
+      end
+
+      # Distributes Full
+      # thread:: Boolean: Uses seperate thread when set to true
+      def dist_full(thread = false)
+        if thread
+          upload_thread("full")
+        else
+          upload(@stats.fullfile, "full")
+        end
+      end
+
+      # Distributes Update and Full
+      # thread:: Boolean: Uses seperate thread when set to true
+      def dist_all(thread = false)
+        dist_update(thread)
+        dist_full(thread)
+        @threads.each { |t| t.join } if thread
+      end
+
+      # Executes Complete Process on Update and Full
+      # create_update, dist_update, nsis_full, dist_full
+      # thread:: Boolean: Uses seperate thread when set to true
+      def complete(thread = true)
+        create_update()
+        dist_update(thread)
+        nsis_full()
+        dist_full(thread)
+        @threads.each { |t| t.join } if thread
+      end
+    end
+  end
+end
+
+component = '6thSense.eu ArmA BuildTools'
+version = '0.7.1'
+SixCore::debugs "#{component} #{version} loaded"
+SixCore::infos("v#{version}, by Sickboy (sb_at_6thSense.eu)", component)

data/lib/sixarma-bt-cli.rb

@@ -0,0 +1,20 @@
+=begin
+  6thSense.eu ArmA BuildTools (Automation Suite), by Sickboy (sb_at_6thSense.eu)
+=end
+
+##
+# load main module
+require 'sixarma/bt'
+require 'sixarma/bt/options'
+
+##
+# Build Program
+builder = SixArma::Bt::Builder.new(
+  @options.configfile,   # Desired Yaml Configuration File
+  @options.halt          # True: will halt after every Major Operation waiting for user to press enter
+)
+
+SixCore::log.debug @options.todo
+@options.todo.each do |t|
+  eval "builder.#{t}"
+end