ratch 0.4.1 → 1.0.0

data/lib/ratch/core_ext/to_list.rb

@@ -0,0 +1,29 @@
+class Array
+
+  def to_list
+    self
+  end
+
+end
+
+class NilClass
+
+  def to_list
+    []
+  end
+
+end
+
+class String
+
+  # Helper method for cleaning list options.
+  # This will split the option on ':' or ';'
+  # if it is a string, rather than an array.
+  # And it will make sure there are no nil elements.
+
+  def to_list
+    split(/[:;,\n]/)
+  end
+
+end
+

data/lib/ratch/dsl.rb

@@ -1,52 +1,497 @@
-# = TITLE:
-#
-#   Main DSL Loader
-#
-# = COPYING:
-#
-#   Copyright (c) 2007 Psi T Corp.
-#
-#   This file is part of the ProUtils' Ratch program.
-#
-#   Ratch 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.
-#
-#   Ratch 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.
+require 'yaml'
+require 'rbconfig'  # replace with facets/rbsystem?
+require 'fileutils'
+
+require 'ratch/core_ext'
+require 'ratch/index'
+require 'ratch/io'
+require 'ratch/runmode'
+
+require 'ratch/task'
+
+require 'facets/platform'
+require 'facets/arguments'
+require 'facets/ziputils'
+
+#require 'annotatable'
+#require 'facets/openhash'
+#require 'facets/argvector'
+
+begin
+  require 'facets/net/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+
+
+module Ratch
+
+  # = Ratch DSL
+  #
+  # The DSL class is the heart of Ratch, it provides all the convenece methods
+  # that make Ratch so convenient for writing Ruby-based batch script.
+  #
+  class DSL < Module
+
+    #
+    def initialize(ioc={})
+      include Taskable
+      include Taskable::Dsl
+
+      extend self
+
+      @runmode = ioc[:mode] || Runmode.load_argv!
+      @io      = ioc[:io]   || IO.new(@runmode)
+    end
+
+    # Delgate run mode settings to Ratch::RunMode object.
+    def runmode
+      @runmode
+    end
+
+    # Delgate input/output routines to Ratch::IO object.
+    def io
+      @io
+    end
+
+    # Delegate file system routines to FileUtils or FileUtils::DryRun,
+    # depending on dryrun mode.
+    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
+
+    #attr_writer :noharm
+    #attr_writer :force
+    #attr_writer :trace
+    #attr_writer :debug
+    #attr_writer :quiet
+    #alias_method :dryrun=, :noharm=
+
+    def force?   ; runmode.force?   ; end
+    def trace?   ; runmode.trace?   ; end
+    def debug?   ; runmode.debug?   ; end
+    def noharm?  ; runmode.noharm?  ; end
+    def dryrun?  ; runmode.dryrun?  ; end
+    def quiet?   ; runmode.quiet?   ; end
+    def verbose? ; runmode.verbose? ; end
+
+    # Current platform.
+    def current_platform
+      Platform.local.to_s
+    end
+
+    # Load configuration data from a file.
+    # Reesults are cached and and 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
+
+    # Shell runner.
+    def shell(cmd)
+      if dryrun?
+        puts cmd
+        true
+      else
+        puts "--> system call: #{cmd}" if trace?
+        if quiet?
+          silently{ system(cmd) }
+        else
+          system(cmd)
+        end
+      end
+    end
+
+    # TODO: DEPRECATE #sh in favor of #shell.
+    alias_method :sh, :shell
+
+    #
+    def commandline
+      #@commandline ||= ArgVector.new(ARGV)
+      @commandline ||= CLI::Arguments.new #(ARGV)
+    end
+
+    # Duplicate of ARGV.
+    #def argv
+    #  @argv ||= ARGV.dup
+    #end
+
+
+    # Convert command line argv to args.
+    #
+    # TODO Is this implmented as expected?
+    #def command_parameters
+    #  ARGV.to_params
+    #end
+
+    # Internal status report.
+    # Only output if dryrun or trace mode.
+    def status(message)
+      io.status(message)
+    end
+
+    # Convenient method to get simple console reply.
+    def ask(question, answers=nil)
+      io.ask(question, answers)
+    end
+
+    # Ask for a password. (FIXME: only for unix so far)
+    def password(prompt=nil)
+      io.password(prompt)
+    end
+
+    # Provides convenient starting points in the file system.
+    #
+    #   root   #=> #<Pathname:/>
+    #   home   #=> #<Pathname:/home/jimmy>
+    #   work   #=> #<Pathname:/home/jimmy/Documents>
+    #
+
+    # Current root path.
+    def root(*args)
+      Pathname['/', *args]
+    end
+
+    # Current home path.
+    def home(*args)
+      Pathname['~', *args].expand_path
+    end
+
+    # Current working path.
+    def work(*args)
+      Pathname['.', *args]
+    end
+
+    alias_method :pwd, :work
+
+    # 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!
+
+#     # Is a file a task?
 #
-#   You should have received a copy of the GNU General Public License
-#   along with Ratch.  If not, see <http://www.gnu.org/licenses/>.
-
-require 'yaml'      # make it generally available
-require 'rbconfig'  # replace with facets/system?
-
-require 'ratch/dsl/options'
-require 'ratch/dsl/batch'
-require 'ratch/dsl/build'
-require 'ratch/dsl/task'
-require 'ratch/dsl/console'
-require 'ratch/dsl/file'
-require 'ratch/dsl/argv'
-require 'ratch/dsl/meta'
-
-# Load ratch dsl functionality into toplevel.
-# This loads into the toplevel's metaclass b/c we don't want
-# all these utilies to invade every object [do we?]
-
-class << self
-  include Ratch::Dsl::Options
-  include Ratch::Dsl::Batch
-  include Ratch::Dsl::Builds
-  include Ratch::Dsl::Tasks
-  include Ratch::Dsl::Filing
-  include Ratch::Dsl::Console
-  include Ratch::Dsl::Argv
-  include Ratch::Dsl::Meta
+#     def task?(path)
+#       task = File.dirname($0) + "/#{path}"
+#       task.chomp!('!')
+#       task if FileTest.file?(task) && FileTest.executable?(task)
+#     end
+
+=begin
+    # Does a path need updating, based on given +sources+?
+    # This compares mtimes of give paths. Returns false
+    # if the path needs to be updated.
+    #
+    # TODO: Put this in FileTest instead?
+
+    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
+=end
+
+    # Glob files.
+    def glob(*args, &blk)
+      Dir.glob(*args, &blk)
+    end
+
+    # Multiglob files.
+    def multiglob(*args, &blk)
+      Dir.multiglob(*args, &blk)
+    end
+
+    # Multiglob recursive.
+    def multiglob_r(*args, &blk)
+      Dir.multiglob_r(*args, &blk)
+    end
+
+    # Stage by hard linking included files to a stage directory.
+    #
+    #   stage_directory   Stage directory.
+    #   files            Files to link to stage.
+    #
+    # TODO: Rename to linkstage or something less likely to name clash?
+
+    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(OverwriteError, 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
+
+      return stage_directory
+    end
+
+    # Delegate access to ZipUtils.
+    #
+    def ziputils
+      dryrun? ? ::ZipUtils::DryRun : ::ZipUtils
+    end
+
+    # Compress directory.
+
+    def compress(format, folder, file=nil, options={})
+      case format.to_s.downcase
+      when 'zip'
+        ziputils.zip(folder, file, options)
+      when 'tgz'
+        ziputils.tgz(folder, file, options)
+      when 'tbz', 'bzip'
+        ziputils.tar_bzip(folder, file, options)
+      else
+        raise ArguementError, "unsupported compression format -- #{format}"
+      end
+    end
+
+    # Create a zip file of a directory.
+    #
+    def zip(folder, file=nil, options={})
+      ziputils.zip(folder, file, options)
+    end
+
+    # Create a tar.bz2 file of a directory.
+    #
+    def tar_bzip(folder, file=nil, options={})
+      ziputils.tar_bzip(folder, file, options)
+    end
+
+    # Create a tgz file of a directory.
+    #
+    def tar_gzip(folder, file=nil, options={})
+      ziputils.tar_gzip(folder, file, options)
+    end
+    alias_method :tgz, :tar_gzip
+
+    #
+    #
+    def naming_policy(*policies)
+      if policies.empty?
+        @naming_policy ||= ['down', 'ext']
+      else
+        @naming_policy = policies
+      end
+    end
+
+    #
+    #
+    def apply_naming_policy(name, ext)
+      naming_policy.each do |policy|
+        case policy
+        when /^low/, /^down/
+          name = name.downcase
+        when /^up/
+          name = name.upcase
+        when /^cap/
+          name = name.capitalize
+        when /^ext/
+          name = name + ".#{ext}"
+        end
+      end
+      name
+    end
+
+    # 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(message, settings)
+      settings ||= {}
+      settings.rekey
+
+      server    = settings[:server]
+      account   = settings[:account]  || ENV['EMAIL_ACCOUNT']
+      passwd    = settings[:password] || ENV['EMAIL_PASSWORD']
+      login     = settings[:login].to_sym
+      subject   = settings[:subject]
+      mail_to   = settings[:to]     || settings[:mail_to]
+      mail_from = settings[:from]   || settings[:mail_from]
+      secure    = settings[:secure]
+      domain    = settings[:domain] || server
+
+      port    ||= (secure ? 465 : 25)
+      account ||= mail_from
+      login   ||= :plain
+
+      #mail_to = nil if mail_to.empty?
+
+      raise ArgumentError, "missing email field -- server"  unless server
+      raise ArgumentError, "missing email field -- account" unless account
+      raise ArgumentError, "missing email field -- subject" unless subject
+      raise ArgumentError, "missing email field -- to"      unless mail_to
+      raise ArgumentError, "missing email field -- from"    unless mail_from
+
+      passwd ||= password(account)
+
+      mail_to = [mail_to].flatten.compact
+
+      msg = ""
+      msg << "From: #{mail_from}\n"
+      msg << "To: #{mail_to.join(';')}\n"
+      msg << "Subject: #{subject}\n"
+      msg << ""
+      msg << message
+
+      begin
+        Net::SMTP.enable_tls if Net::SMTP.respond_to?(:enable_tls) and secure
+        Net::SMTP.start(server, port, domain, account, passwd, login) do |s|
+          s.send_message( msg, mail_from, mail_to )
+        end
+        puts "Email sent successfully to #{mail_to.join(';')}."
+        return true
+      rescue => e
+        if trace?
+          raise e
+        else
+          abort "Email delivery failed."
+        end
+      end
+    end
+
+  end
+
 end
 
-# run main task
-END { run_main }