ratch 1.1.0 → 1.2.0

data/lib/ratch/system.rb

@@ -0,0 +1,15 @@
+module Ratch
+
+  # TODO: Build it!
+  #
+  # The System class provides a robust interface for interacting with
+  # system commands. It is essenatially a wrapper around popen3 or popen4.
+  #
+  # Having a separate class rather integrating this into Shell (as 
+  # Ruby's standard Shell class does) provides a better SOC.
+  #
+  class System
+
+  end
+
+end

data/lib/ratch/utils/cli.rb

@@ -0,0 +1,49 @@
+module Ratch
+
+  # TODO: How best to support CLI interface?
+  module CLI
+
+    #
+    def self.included(base)
+      require 'facets/argvector'
+    end
+
+    #
+    def self.extended(base)
+      require 'facets/argvector'
+    end
+
+    #
+    def initialize(*args)
+      argv = ArgVector.new(ARGV)
+
+      @arguments, parameters = *argv.parameters
+
+      args << {} unless Hash === args.last
+
+      opts = args.last
+
+      opts.merge!(parameters)
+
+      super(*args)
+    end
+
+    #
+    def arguments
+      @arguments
+    end
+
+    # DEPRECATE!
+    #alias_method :commandline, :cli
+
+    # DEPRECATE!
+    #alias_method :command, :cli
+
+    #
+    #def commandline
+    #  #@commandline ||= ArgVector.new(ARGV)
+    #  @commandline
+    #end
+  end
+
+end

data/lib/ratch/utils/config.rb

@@ -0,0 +1,52 @@
+module Ratch
+
+  # Utility extensions for working with configuration files.
+  #--
+  # TODO: Perhaps utilize confectionary gem in future?
+  #++
+  module ConfigUtils
+
+    #
+    def self.included(base)
+      require 'yaml'
+    end
+
+    def self.extended(base)
+      included(base)
+    end
+
+    # Load configuration data from a file. Results are cached and an empty
+    # Hash is returned if the file is not found.
+    #
+    # Since they are YAML files, they can optionally end with '.yaml' or '.yml'.
+    def configuration(file)
+      @configuration ||= {}
+      @configuration[file] ||= (
+        begin
+          configuration!(file)
+        rescue LoadError
+          Hash.new{ |h,k| h[k] = {} }
+        end
+      )
+    end
+
+    # Load configuration data from a file. The "bang" version will raise an error
+    # if file is not found. It also does not cache the results.
+    #
+    # Since they are YAML files, they can optionally end with '.yaml' or '.yml'.
+    def configuration!(file)
+      @configuration ||= {}
+      patt = file + "{.yml,.yaml,}"
+      path = Dir.glob(patt, File::FNM_CASEFOLD).find{ |f| File.file?(f) }
+      if path
+        # The || {} is in case the file is empty.
+        data = YAML::load(File.open(path)) || {}
+        @configuration[file] = data
+      else
+        raise LoadError, "Missing file -- #{path}"
+      end
+    end
+
+  end
+
+end

data/lib/ratch/{emailer.rb → utils/email.rb}

@@ -1,11 +1,37 @@
-begin
-  require 'facets/net/smtp_tls'
-rescue LoadError
-  require 'net/smtp'
-end
+module Ratch
 
+  # The Mail utility module provides an easy to use +email+ method.
+  module EmailUtils
 
-module Ratch
+    # Email function to easily send out an email.
+    #
+    # Settings:
+    #
+    #     subject      Subject of email message.
+    #     from         Message FROM address [email].
+    #     to           Email address to send announcemnt.
+    #     server       Email server to route message.
+    #     port         Email server's port.
+    #     domain       Email server's domain name.
+    #     account      Email account name if needed.
+    #     password     Password for login..
+    #     login        Login type: plain, cram_md5 or login [plain].
+    #     secure       Uses TLS security, true or false? [false]
+    #     message      Mesage to send -or-
+    #     file         File that contains message.
+    #
+    def email(options)
+      options[:file] = localize(options[:file]) if options[:file]
+      emailer = Emailer.new(options.rekey)
+      success = emailer.email
+      if Exception === success
+        puts "Email failed: #{success.message}."
+      else
+        puts "Email sent successfully to #{success.join(';')}."
+      end
+    end
+
+  end
 
   # Emailer class makes it easy send out an email.
   #
@@ -67,6 +93,8 @@ module Ratch
 
     #
     def initialize(options={})
+      require_smtp
+
       options = options.rekey
 
       if not options[:server]
@@ -171,6 +199,15 @@ module Ratch
       return inp
     end
 
+    #
+    def require_smtp
+      begin
+        require 'facets/net/smtp_tls'
+      rescue LoadError
+        require 'net/smtp'
+      end
+    end
+
   end
 
 end

data/lib/ratch/utils/ftp.rb

@@ -0,0 +1,134 @@
+module Ratch
+
+  # FIXME: This module needs major work. Methods #ftp_files and
+  # ftp_stage_transfer need to either be generalized and moved to
+  # Shell or Script, or removed.
+  #
+  module FTPUtils
+
+    def self.included(base)
+      require 'net/ftp'
+      require 'net/sftp'
+    end
+
+    def self.extended(base)
+      included(base)
+    end
+
+    # Use ftp to upload files.
+    #
+    def ftp(keys)
+      keys = upload_parameters(keys)
+
+      # set transfer rules
+      if keys.stage
+        trans = ftp_stage_transfer(keys.stage)
+      else
+        ftp_files(keys.dir, keys.copy).each do |from|
+          trans << [from,from]
+        end
+      end
+
+      # append location of publication dir to from
+      dir = keys.dir
+      trans.collect!{ |from,to| [File.join(dir,from), to] }
+
+      if keys.dryrun
+        puts "ftp open #{keys.user}@#{keys.host}:#{keys.root}/"
+        keys.trans.each do |f, t|
+          puts "ftp put #{f} #{t}"
+        end
+      else
+        Net::FTP.open(keys.host) do |ftp|
+          ftp.login(keys.user) #password?
+          ftp.chdir(keys.root)
+          keys.trans.each do |f, t|
+            puts "ftp #{f} #{t}" unless keys.quiet
+            ftp.putbinaryfile( f, t, 1024 )
+          end
+        end
+      end
+    end
+
+    # Use sftp to upload files.
+    #
+    def sftp( keys )
+      keys = upload_parameters(keys)
+
+      # set transfer rules
+      if keys.stage
+        trans = ftp_stage_transfer(keys.stage)
+      else
+        ftp_files(keys.dir, keys.copy).each do |from|
+          trans << [from,from]
+        end
+      end
+
+      # append location of publication dir to from
+      dir = keys.dir
+      trans.collect!{ |from,to| [File.join(dir,from), to] }
+
+      if keys.dryrun
+        puts "sftp open #{keys.user}@#{keys.host}:#{keys.root}/"
+        keys.trans.each do |f,t|
+          puts "sftp put #{f} #{t}"
+        end
+      else
+        Net::SFTP.start(keys.host, keys.user, keys.pass) do |sftp|
+          #sftp.login( user )
+          sftp.chdir(keys.root)
+          keys.trans.each do |f,t|
+            puts "sftp #{f} #{t}" unless keys.quiet
+            sftp.put_file(f,t) #, 1024 )
+          end
+        end
+      end
+    end
+
+    # Put together the list of files to copy.
+    def ftp_files( dir, copy )
+      Dir.chdir(dir) do
+        del, add = copy.partition{ |f| /^[-]/ =~ f }
+
+        # remove - and + prefixes
+        del.collect!{ |f| f.sub(/^[-]/,'') }
+        add.collect!{ |f| f.sub(/^[+]/,'') }
+
+        #del.concat(must_exclude)
+
+        ftp_files = []
+        add.each{ |g| files += Dir.glob(g) }
+        del.each{ |g| files -= Dir.glob(g) }
+
+        files.collect!{ |f| f.sub(/^\//,'') }
+
+        return files
+      end
+    end
+
+    # Combine three part stage list into a two part from->to list.
+    #
+    # Using the stage list of three space separated fields.
+    #
+    #   fromdir file todir
+    #
+    # This is used to generate a from -> to list of the form:
+    #
+    #  fromdir/file todir/file
+    #
+    def ftp_stage_transfer( list )
+      trans = []
+      list.each do |line|
+        trans << Shellwords.shellwords(line)
+      end
+
+      trans.collect! do |from, base, to|
+        file = File.join(from,base)
+        to = File.join(to,base)
+        [from, to]
+      end
+    end
+
+  end
+
+end

data/lib/ratch/utils/pom.rb

@@ -0,0 +1,22 @@
+module Ratch
+
+  # Methods for utilizing Ruby POM.
+  module POMUtils
+
+    def self.included(base)
+      require 'pom'
+    end
+
+    def self.extended(base)
+      included(base)
+    end
+
+    #
+    def project
+      @project ||= ::POM::Project.new
+    end
+
+  end
+
+end
+

data/lib/ratch/utils/rdoc.rb

@@ -0,0 +1,48 @@
+module Ratch
+
+  # Provides a pure-Ruby method for generating RDocs.
+  module RDocUtils
+
+    DEFAULT_RDOC_OPTIONS = {
+      :quiet => true
+    }
+
+    # RDoc command.
+    #
+    # :call-seq:
+    #   rdoc(file1, file2, ..., :opt1 => val1, ...)
+    #
+    def rdoc(*files)
+      require 'rdoc/rdoc'
+
+      options = Hash===files.last ? files.pop : {}
+      options.rekey!(&:to_s)
+
+      options['title'] ||= options.delete('T')
+
+      options['debug']   = options['debug']   #|| debug?
+      options['quiet']   = options['quiet']   #|| quiet?
+      options['verbose'] = options['verbose'] #|| verbose?
+
+      # apply pom (todo?)
+      #options['title'] ||= metadata.title
+
+      options = DEFAULT_RDOC_OPTIONS.merge(options)
+
+      locally do
+        rdoc = RDoc::RDoc.new
+        opts = options.to_argv + files
+        $stderr.puts("rdoc " + opts.join(' ')) if ($VERBOSE || $DEBUG)
+        disable_warnings do
+          rdoc.document(options.to_argv + files)
+        end
+      end
+    end
+
+    #
+    # TODO: Implement ri doc generator.
+
+  end
+
+end
+

data/lib/ratch/utils/tar.rb

@@ -0,0 +1,88 @@
+require 'ratch/utils/zlib'
+
+module Ratch
+
+  # Utility methods for working with tarballs archives.
+  #--
+  # TODO: Add compress support ?
+  # TODO: Add bzip support ?
+  #++
+  module TarUtils
+
+    # When included include GZipUtils too.
+    def self.included(base)
+      #require 'zlib'
+      include ZLibUtils
+      require 'archive/tar/minitar'
+    end
+
+    #
+    def self.extended(base)
+      included(base)
+    end
+
+    # Tar
+    def tar(folder, file=nil, options={})
+      noop, verbose = *util_options(options)
+      file ||= File.basename(File.expand_path(folder)) + '.tar'
+      cmd = "tar -cf #{file} #{folder}"
+      puts cmd if verbose
+      unless noop
+        locally do
+          gzIO = File.open(file, 'wb')
+          Archive::Tar::Minitar.pack(folder, gzIO)
+        end
+      end
+      path(file)
+    end
+
+    # Untar
+    def untar(file, options={})
+      noop, verbose = *util_options(options)
+      #file ||= File.basename(File.expand_path(folder)) + '.tar'
+      cmd = "untar #{file}"
+      puts cmd if verbose
+      unless noop
+        locally do
+          gzIO = File.open(file, 'wb')
+          Archive::Tar::Minitar.unpack(gzIO)
+        end
+      end
+      path(file)
+    end
+
+    # Tar Gzip
+    def tar_gzip(folder, file=nil, options={})
+      noop, verbose = *util_options(options)
+      file ||= File.basename(File.expand_path(folder)) + '.tar.gz' # '.tgz' which ?
+      cmd = "tar --gzip -czf #{file} #{folder}"
+      puts cmd if verbose
+      unless noop
+        locally do #folder, file = localize(folder), localize(file)
+          gzIO = Zlib::GzipWriter.new(File.open(file, 'wb'))
+          Archive::Tar::Minitar.pack(folder, gzIO)
+        end
+      end
+      path(file)
+    end
+
+    alias_method :tar_z, :tar_gzip
+
+    # Untar Gzip
+    #
+    # FIXME: Write unified untar_gzip function.
+    def untar_gzip(file, options={})
+      untar(ungzip(file, options), options)
+    end
+
+    alias_method :untar_z, :untar_gzip
+
+    #def tgz(folder, file=nil, options={})
+    #  file ||= File.basename(File.expand_path(folder)) + '.tgz'
+    #  tar_gzip(folder, file, options)
+    #end
+
+  end
+
+end
+