reap 6.0.2 → 9.2.0

data/lib/reap/systems/subversion.rb

@@ -0,0 +1,333 @@
+require 'reap/utilities/shellutils'
+require 'reap/utilities/fileutils'
+
+module Reap
+
+  class Subversion
+    include Utilities::ShellUtils
+    include Utilities::FileUtils
+
+    # Project name (for repository).
+
+    attr_accessor :project
+
+    # Current version of project.
+
+    attr_accessor :version
+
+    # Developers URL to repository. Defaults to Rubyforge address.
+
+    attr_accessor :repository
+
+    # Username. Defaults to ENV['RUBYFORGE_USERNAME'].
+
+    attr_accessor :username
+
+    # The URL protocol to use. Defaults to "svn+ssh".
+
+    attr_accessor :protocol
+
+    # Prefix to use on tag folder. Default is no prefix.
+
+    attr_accessor :prefix
+
+    # Optional commit message. This is intended for commandline
+    # usage. (Use -m for shorthand).
+
+    attr_accessor :message
+
+    # Directory to store tags. Defaults to tags/.
+
+    attr_accessor :tagpath
+
+    # Directory to store branches. Defaults to branches/.
+
+    attr_accessor :branchpath
+
+    # Operate in dryrun mode.
+
+    attr_accessor :dryrun
+
+    # New Subversion object.
+    #
+    # TODO: Perhaps format prefix, like: 
+    #       prefix  = prefix + '_' if prefix && prefix !~ /[_-]$/
+
+    def initialize(options={})
+      options.each do |k,v|
+        send("#{k}=", v) if respond_to?("#{k}=")
+      end
+
+      # defaults are for rubyforge
+      @repository ||= "rubyforge.org/var/svn/#{project}"
+      @username   ||= ENV['RUBYFORGE_USERNAME']
+      @protocol   ||= "svn+ssh"
+      @tagpath    ||= "tags"
+      @branchpath ||= "branches"
+
+      if i = @repository.index('//')
+        @repository = @repository[i+2..-1]
+      end
+    end
+
+    # Developer domain is "username@repository".
+
+    def developer_domain
+      "#{username}@#{repository}"
+    end
+
+    # Branch current version.
+    #
+    #   message       Optional commit message. This is intended for commandline
+    #                 usage. (Use -m for shorthand).
+    #
+    def branch(options={})
+      msg  = options['message'] || options['m']
+      name = "#{prefix}#{version}"
+      path = branchpath.to_s
+
+      if path == '.' or path.empty?
+        url = "#{protocol}://" + File.join(developer_domain, name)
+      else
+        url = "#{protocol}://" + File.join(developer_domain, path, name)
+      end
+
+      case ask("Branch: #{url} ? [yN]").strip.downcase
+      when 'y', 'yes'
+        #sh "svn copy #{protocol}://#{username}@#{repository}/trunk #{url}"
+        sh "svn copy . #{url}"
+      end
+    end
+
+    # Tag current version.
+    #
+    #   message       Optional commit message. This is intended for commandline
+    #                 usage. (Use -m for shorthand).
+    #
+    def tag(options={})
+      msg  = options['message'] || options['m']
+      name = "#{prefix}#{version}"
+      path = tagpath.to_s
+
+      if path == '.' or path.empty?
+        url = "#{protocol}://" + File.join(developer_domain, name)
+      else
+        url = "#{protocol}://" + File.join(developer_domain, path, name)
+      end
+
+      case ask("Tag: #{url} ? [yN]").strip.downcase
+      when 'y', 'yes'
+        #sh "svn copy #{protocol}://#{username}@#{repository}/trunk #{url}"
+        sh "svn copy . #{url}"
+      end
+    end
+
+    # Create a change log.
+    #
+    #   change     File name to store rdoc formated changelog. Default is 'changelog.txt'.
+    #
+    #   output     Path to store rdoc formated changelog. Default is 'log'.
+    #
+    #   xmlchange  File name to store XML formated changelog. Default is 'changelog.xml'.
+    #              This also creates a file, if needed, by the same name but with .xsl extension.
+    #
+    #   xmloutput  Path to store XML-formated changelog. Default is 'doc/log'.
+    #
+    # If change or xmlchange contain a path separator ('/', not '\'), then it is assumed they
+    # provide their own path and the output fields will not be used. This allows you to set
+    # +change+ to "./CHANGES" for instance, without effecting the location of other logs.
+    # You can also set change or xmlchange to 'false' to supress creation altogether.
+    #
+    # TODO: Allow for a way to dump the text-based Changelog to standard out. "$stdout" as the filename?
+    # TODO: How to apply naming policy from here?
+
+    def log(file=nil)
+      #txtlog = file #options['change']    || 'changelog.txt'
+      #txtdir = options['output']    || 'log'
+      #xmllog = options['xmlchange'] || 'changelog.xml'
+      #xmldir = options['xmloutput'] || 'doc/log'
+      #txtlog = File.join(txtdir, txtlog) unless xmllog.include?('/')
+      #xmllog = File.join(xmldir, xmllog) unless xmllog.include?('/')
+      text = changelog_text
+      if dryrun?
+        puts "svn log > #{file}"
+      elsif file
+        mkdir_p(File.dirname(file))
+        File.open(file, 'w'){|f| f << text }
+        puts "Updated #{file}"
+      else
+         puts text
+      end
+    end
+
+    #
+
+    def log_xml(file)
+      #xmldir = options['xmloutput'] || 'doc/log'
+
+      xslfile = file.chomp(File.extname(file)) + '.xsl'
+      log_xsl(xslfile)
+
+      text = changelog_xml
+      i = text.index("?>\n")
+      text.insert(i+2, "\n" + %[<?xml-stylesheet href="#{xslfile}" type="text/xsl" ?>])
+
+      if dryrun?
+        puts "svn log --xml > #{file}"
+      elsif file
+        mkdir_p(File.dirname(file))
+        File.open(file, 'w'){ |f| f << text }
+        puts "Updated #{file}"
+      else
+        puts text
+      end
+    end
+
+    private
+
+    def changelog_xml
+      @changelog_xml ||= `svn log --xml`
+    end
+
+    def changelog_text
+      @changelog_text ||= log_format(log_organize(log_parse(changelog_xml)))
+    end
+
+    # Parse xml log into rdoc markup.
+
+    def log_parse(xml)
+      require "rexml/document"
+      changes = []
+      doc = REXML::Document.new(xml)
+      doc.root.elements.each do |element|
+        revision = element.attributes["revision"]
+        author   = element.elements["author"].text
+        date     = element.elements["date"].text
+        message  = element.elements["msg"].text
+
+        revision = revision.strip
+        author   = author.strip
+        date     = Date.parse(date)
+        message  = message.strip
+
+        changes << [ date, author, revision, message ]
+      end
+      changes
+    end
+
+    #
+
+    def log_organize(changes)
+      mapped = {}
+      changes.each do |date, who, rev, text|
+        mapped[[date, who]] ||= []
+        mapped[[date, who]] << [text, rev]
+      end
+      sorted = []
+      mapped.each do |(date, who), entries|
+        sorted << [ date, who, entries ]
+      end
+      sorted.sort{ |a,b| b[0] <=> a[0] }
+    end
+
+    #
+
+    def log_format(sorted)
+      string = "= Subversion Changelog\n\n"
+      sorted.each do |date, who, entries|
+        string << "== #{date}  #{who}\n\n"  # no email :(
+        entries.each do |entry|
+          string << "* #{entry.first} (#{entry.last})\n"
+        end
+        string << "\n"
+      end
+      string
+    end
+
+    #
+
+    def log_xsl(xslfile)
+      if force? or not File.exist?(xslfile)
+        mkdir_p(File.dirname(xslfile))
+        if dryrun?
+          puts "touch #{xslfile}"
+        else
+          File.open(xslfile, 'w') do |f|
+            f << DEFAULT_LOG_XSL
+          end
+        end
+      end
+    end
+
+DEFAULT_LOG_XSL = <<-END
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+
+  <xsl:output cdata-section-elements="script"/>
+
+  <xsl:template match="/">
+    <html>
+      <head>
+        <title>Changelog</title>
+        <link REL='SHORTCUT ICON' HREF="../img/ruby-sm.png" />
+        <style>
+          td { font-family: sans-serif;  padding: 0px 10px; }
+        </style>
+      </head>
+      <body>
+      <div class="container">
+        <h1>Changelog</h1>
+        <table style="width: 100%;">
+          <xsl:apply-templates />
+        </table>
+      </div>
+      </body>
+    </html>
+  </xsl:template>
+
+  <xsl:template match="logentry">
+      <tr>
+        <td><b><pre><xsl:value-of select="msg"/></pre></b></td>
+        <td><xsl:value-of select="author"/></td>
+        <td><xsl:value-of select="date"/></td>
+      </tr>
+  </xsl:template>
+
+</xsl:stylesheet>
+END
+
+  end
+
+end
+
+
+
+=begin
+    #
+
+    def svn_repository_configuration(options, *entries)
+      entries << 'svn'
+      options = configure_options(options, *entries)
+
+      options['repository'] ||= metadata.repository
+      options['protocol']   ||= 'svn+ssh'
+      options['message']    ||= options.delete('m')
+      options['tagpath']    ||= 'tags'
+
+      unless repository
+        rubyforge   = configuration['rubyforge'] || {}
+        projectname = rubyforge['project'] || metadata.name
+        options['repository']  = "rubyforge.org/var/svn/#{projectname}"
+      end
+
+      if i = options['repository'].index('//')
+        options['repository'] = options['repository'][i+2..-1]
+      end
+
+      if /rubyforge.org/i =~ options['repository']
+        options['username'] ||= ENV['RUBYFORGE_USERNAME']
+      end
+
+      return options
+    end
+=end
+

data/lib/reap/utilities/fileutils.rb

@@ -0,0 +1,304 @@
+# = TITLE:
+#
+#   File Utitlies
+#
+# = COPYING:
+#
+#   Copyright (c) 2007,2008 Tiger Ops
+#
+#   This file is part of the Reap program.
+#
+#   Reap is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   Reap is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with Reap.  If not, see <http://www.gnu.org/licenses/>.
+#
+# TODO:
+#
+#   - Move out_of_data? and safe? to Facets FileTest extensions.
+
+require 'fileutils'
+require 'facets/ziputils'
+
+require 'reap/extensions'
+
+#
+module Reap
+module Utilities
+
+  module FileUtils
+
+    # Delegate access to FileUtils.
+
+    def fileutils
+      dryrun? ? ::FileUtils::DryRun : ::FileUtils
+    end
+
+    # Add FileUtils Features
+
+    ::FileUtils.private_instance_methods(false).each do |meth|
+      next if meth =~ /^fu_/
+      module_eval %{
+        def #{meth}(*a,&b)
+          fileutils.#{meth}(*a,&b)
+        end
+      }
+    end
+
+    # Add FileTest Features
+
+    ::FileTest.private_instance_methods(false).each do |meth|
+      next if meth =~ /^fu_/
+      module_eval %{
+        def #{meth}(*a,&b)
+          FileTest.#{meth}(*a,&b)
+        end
+      }
+    end
+
+    # Specific.
+
+    def rm_r(*a)
+      if dryrun?
+        puts "rm_r #{a.join(' ')}"
+      else
+        fileutils.rm_r(*a)
+      end
+    end
+
+    # Bonus FileUtils features.
+
+    def cd(*a,&b)
+      puts "cd #{a}" if dryrun? or trace?
+      fileutils.chdir(*a,&b)
+    end
+
+    # Read file.
+
+    def file_read(path)
+      File.read(path)
+    end
+
+    # Write file.
+
+    def file_write(path, text)
+      if dryrun?
+        puts "write #{path}"
+      else
+        File.open(path, 'w'){ |f| f << text }
+      end
+    end
+
+    # Assert that a path exists.
+
+    def exists?(path)
+      paths = Dir.glob(path)
+      paths.not_empty?
+    end
+    alias_method :exist?, :exists? ; module_function :exist?
+    alias_method :path?,  :exists? ; module_function :path?
+
+    # Assert that a path exists.
+
+    def exists!(*paths)
+      abort "path not found #{path}" unless paths.any?{|path| exists?(path)}
+    end
+    alias_method :exist!, :exists! ; module_function :exist!
+    alias_method :path!,  :exists! ; module_function :path!
+
+    # Is a given path a regular file? If +path+ is a glob
+    # then checks to see if all matches are refular files.
+
+    def file?(path)
+      paths = Dir.glob(path)
+      paths.not_empty? && paths.all?{ |f| FileTest.file?(f) }
+    end
+
+    # Assert that a given path is a file.
+
+    def file!(*paths)
+      abort "file not found #{path}" unless paths.any?{|path| file?(path)}
+    end
+
+    # Is a given path a directory? If +path+ is a glob
+    # checks to see if all matches are directories.
+
+    def dir?(path)
+      paths = Dir.glob(path)
+      paths.not_empty? && paths.all?{ |f| FileTest.directory?(f) }
+    end
+    alias_method :directory?, :dir? ; module_function :directory?
+
+    # Assert that a given path is a directory.
+
+    def dir!(*paths)
+      paths.each do |path|
+        abort "Directory not found: '#{path}'." unless  dir?(path)
+      end
+    end
+    alias_method :directory!, :dir! ; module_function :directory!
+
+#     # Okay, I'm being a dork, but 'fold' seems like a better word
+#     # then 'dir', 'folder', or 'directory'.
+#
+#     def fold?(path)
+#       paths = Dir.glob(path)
+#       paths.not_empty? && paths.all?{ |f| FileTest.directory?(f) }
+#     end
+#
+#     # Assert that a given path is a fold (ie. a folder).
+#
+#     def fold!(*paths)
+#       abort "fold not found #{path}" unless paths.any?{|path| fold?(path)}
+#     end
+
+    # Return a cached list of the PATH environment variable.
+    # This is a support method used by #bin?
+
+    def command_paths
+      @command_paths ||= ENV['PATH'].split(/[:;]/)
+    end
+
+    # Is a file a command executable?
+    #
+    # TODO: Make more robust. Probably needs to be fixed for Windows.
+
+    def bin?(fname)
+      #@command_paths ||= ENV['PATH'].split(/[:;]/)
+      is_bin = command_paths.any? do |f|
+        FileTest.exist?(File.join(f, fname))
+      end
+      #is_bin ? File.basename(fname) : false
+      is_bin ? fname : false
+    end
+
+    # Is a path considered reasonably "safe"?
+    #
+    # TODO: Make more robust.
+
+    def safe?(path)
+      case path
+      when *[ '/', '/*', '/**/*' ]
+        return false
+      end
+      true
+    end
+
+    # Does a path need updating, based on given +sources+?
+    # This compares mtimes of give paths. Returns false
+    # if the path needs to be updated.
+
+    def out_of_date?(path, *sources)
+      return true unless File.exist?(path)
+
+      sources = sources.collect{ |source| Dir.glob(source) }.flatten
+      mtimes  = sources.collect{ |file| File.mtime(file) }
+
+      return true if mtimes.empty?  # TODO: This the way to go here?
+
+      File.mtime(path) < mtimes.max
+    end
+
+    # Glob files.
+
+    def glob(*args, &blk)
+      Dir.glob(*args, &blk)
+    end
+
+    def multiglob(*args, &blk)
+      Dir.multiglob(*args, &blk)
+    end
+
+    def multiglob_r(*args, &blk)
+      Dir.multiglob_r(*args, &blk)
+    end
+
+    # Stage package by hard linking included files to a stage directory.
+    # Stage files in a directory.
+    #
+    #   stage_directory       Stage directory.
+    #   files                 Files to link to stage.
+
+    def stage(stage_directory, files)
+      return stage_directory if dryrun?           # Don't link to stage if dryrun.
+
+      if File.directory?(stage_directory)         # Ensure existance of staging area.
+        #raise(???Error, stage_directory) unless force?
+        rm_r(stage_directory)
+      end
+
+      mkdir_p(stage_directory)                    #dir = File.expand_path(stage)
+
+      #files = package.filelist  #+ [package.manifest_file]
+
+      # TODO Dryrun test here or before folder creation?
+      files.each do |f|                 # Link files into staging area.
+        file = File.join(stage_directory, f)
+        if File.directory?(f)
+          mkdir_p(file)
+        else
+          unless File.exist?(file) and File.mtime(file) >= File.mtime(f)
+            ln(f, file) #safe_ln ?
+          end
+        end
+      end
+
+      # stage meanifest ?
+
+      return stage_directory
+    end
+
+    # Create manifest for a directory.
+    #
+    # TODO: Do this programatically rather then via shell.
+
+    def stage_manifest(directory)
+      cd(directory) do
+        sh 'manifest up'
+      end
+    end
+
+    # Delegate access to ZipUtils.
+
+    def ziputils
+      dryrun? ? ::ZipUtils::DryRun : ::ZipUtils
+    end
+
+    # Zip folder into file.
+
+    def zip(folder, file=nil, options={})
+      ziputils.zip(folder, file, options)
+    end
+
+    # BZip and tarball folder into file.
+
+    def tar_bzip(folder, file=nil, options={})
+      ziputils.tar_bzip(folder, file, options)
+    end
+
+    # GZip and tarball folder into file. Shortcut for ziputils.tgz.
+
+    def tgz(folder, file=nil, options={})
+      ziputils.tgz(folder, file, options)
+    end
+
+#     # Is a file a task?
+#
+#     def task?(path)
+#       task = File.dirname($0) + "/#{path}"
+#       task.chomp!('!')
+#       task if FileTest.file?(task) && FileTest.executable?(task)
+#     end
+
+  end
+
+end
+end