ratch 0.1

data/lib/ratch/batch.rb

@@ -0,0 +1,43 @@
+#require 'shellwords'
+require 'rbconfig'  # replace with facets/rbsystem in future ?
+require 'ratch/taskutils'
+
+module Ratch
+
+  # Batch File class, is used as an executionm context for a
+  # ratch script.
+
+  class BatchFile < Module
+
+    include TaskUtils
+
+    # Quick start, equivalent to calling new.run(file).
+
+    #def self.start(file)
+    #  new(file).call
+    #end
+
+    # New Batch File
+
+    def initialize(file)
+      abort "missing batch file -- #{file}" unless File.file?(file)
+      @file = file
+    end
+
+    # TODO What todo about arguments?
+
+    def call(arguments=nil)
+      script = File.read($0 = @file)
+      eval(script, binding, $0) #instance_eval(script)
+      @main.call if @main
+    end
+
+  end
+
+end
+
+# Load TaskUtils directly into to main runspace.
+
+#class << self
+#  include TaskUtils
+#end

data/lib/ratch/cli/lt.rb

@@ -0,0 +1,56 @@
+#! /usr/bin/ruby1.8
+
+# scan task scripts for descriptions
+
+def script_desc( dir )
+  help = {}
+  files = Dir.glob( File.join( dir, '*' ) )
+  files.each do |fname|
+    next if FileTest.directory?( fname )
+    next unless FileTest.executable?( fname )
+    desc = ''
+    File.open(fname) do |f|
+      line = ''
+      until f.eof?
+        line = f.gets
+        case line
+        when /^(#!|\s*$)/
+          next
+        when /^\s*#(.*)/
+          desc = $1.strip; break
+        else
+          desc = nil; break
+        end
+      end
+    end
+    help[File.basename(fname)] = desc
+  end
+  help
+end
+
+def show( dir )
+  tasks = script_desc( dir )
+  max = tasks.keys.max{ |a,b| a.size <=> b.size }.size
+  if dir == ''
+    max += 4 + 2
+  else
+    max += dir.size + 2
+  end
+  tasks.each do |name, sum|
+    #sum = Sake.help_summary( type )
+    if dir == ''
+      cmd = "sake #{name}"
+    else
+      cmd = File.join( dir.chomp('/'), name )
+    end
+    puts "%-#{max}s # %s" % [cmd, sum]
+  end
+end
+
+dir = ARGV[0] || '.'
+
+if File.directory?( dir )
+  show( dir )
+else
+  puts "#{dir} is not a directory"
+end

data/lib/ratch/cli/ludo.rb

@@ -0,0 +1,14 @@
+#! /usr/bin/ruby1.8
+
+require 'facets/filetest'
+
+name = ARGV[0]
+
+if name
+  Dir.chdir '..' until FileTest.executable?(name) or FileTest.root?(Dir.pwd)
+  if FileTest.executable?( name )
+    system name
+  end
+else
+  puts "Script #{name} not found."
+end

data/lib/ratch/cli/ratch.rb

@@ -0,0 +1,47 @@
+#require 'shellwords'
+require 'rbconfig'  # replace with facets/rbsystem in future ?
+require 'ratch/batch'
+
+module Ratch
+
+  class RatchCommand
+
+    # Quick start.
+
+    def self.start(file)
+      new.run(file)
+    end
+
+    # Run task.
+
+    def run(file)
+      if file
+        BatchFile.new(file).call
+      else
+        help
+      end
+    end
+
+    # Dispaly help.
+
+    def help
+      help = <<-END
+       USAGE:
+
+         ratch [options] <taskfile>
+
+       OPTIONS:
+
+         --dryrun --nohram
+
+         --trace
+
+         --debug
+      END
+      puts help.gsub(/^\s+/, '')
+    end
+
+  end
+
+
+end

data/lib/ratch/configutils.rb

@@ -0,0 +1,100 @@
+
+module Ratch
+
+  module ConfigUtils
+
+    DEFAULT_CONFIG_FILE = 'config'
+
+    #
+
+    def configuration(file=nil)
+      @configuration ||= {}
+      if file = config_file(file)
+        @configuration[file] ||= config_read(file)
+      else
+        @configuration[file] ||= Hash.new{ |h,k| h[k] = {} }
+      end
+    end
+
+    #
+
+    def config_file(path=nil)
+      path ||= DEFAULT_CONFIG_FILE
+      find = "{#{utility_directory}/,}#{path}{.yaml,.yml,}"
+      file = Dir.glob(find)[0]
+      return file
+    end
+
+    # Load configuration data from a file. THe file will
+    # be looked for in the current script directory then
+    # from the project root.
+    #
+    # Since they are YAML files, they can optionally
+    # end with '.yaml' or '.yml'.
+
+    def config_read(path)
+      find = "{#{utility_directory}/,}#{path}{.yaml,.yml,}"
+      if file = Dir.glob(find)[0]
+        YAML::load(File.open(file))
+      else
+        raise LoadError, "Missing file -- #{path}"
+      end
+    end
+
+    # TODO Better name? Better definition? (Won't handle task subdirs well).
+
+    def utility_directory
+      File.dirname($0)
+    end
+
+    # Create an argument vector from a set of config options.
+    # TODO Deprecate in favor of Hash extension.
+
+    def config_vector(config, args_field=nil)
+      config.command_vector(args_field)
+    end
+
+#     # FIXME ProjectInfo, if available.
+#
+#     def projectinfo
+#       require 'box/project'
+#       @projectinfo
+#
+#       #begin
+#       #  @projectinfo = ProjectInfo.open
+#       #rescue LoadError
+#       #  @projectinfo = nil
+#       #end
+#     end
+
+#     def config_file
+#       @config_file ||= (
+#         dir  = utility_directory
+#         name = Dir.basename(dir)
+#         Dir.glob("{#{dir},meta,info,}/{#{name},config}{.yaml,.yml}")
+#       )
+#     end
+
+#     # Load task configuration if any.
+#
+#     def config_load(*names) #, defaults=nil)
+#
+#       names.inject({}) do |memo, name|
+#         name     = name.to_s
+#         #defaults = defaults || {}
+#
+#         if file = config_file(name)
+#           config = YAML.load(File.open(file))
+#         elsif file = Dir.glob("#{utility_directory}/config{,.yaml,.yml}")[0]
+#           config = YAML.load(File.open(file))[name.to_s]
+#         else
+#           config = {}
+#         end
+#
+#         config.update(memo)
+#       end
+#       #return defaults.update(config || {})
+#     end
+
+  end
+end

data/lib/ratch/consoleutils.rb

@@ -0,0 +1,88 @@
+module Ratch
+
+  module ConsoleUtils
+
+    # Convenient method to get simple console reply.
+
+    def ask(question, answers=nil)
+      print "#{question}"
+      print " [#{answers}] " if answers
+      until inp = $stdin.gets ; sleep 1 ; end
+      inp
+    end
+
+    # Ask for a password. (FIXME: only for unix so far)
+
+    def password(prompt=nil)
+      msg ||= "Enter Password: "
+      inp = ''
+
+      print "#{prompt} "
+
+      begin
+        system "stty -echo"
+        #inp = gets.chomp
+        until inp = $stdin.gets
+          sleep 1
+        end
+      ensure
+        system "stty echo"
+      end
+
+      return inp.chomp
+    end
+
+  end
+
+end
+
+
+class Array
+
+  # Convert an array into command line parameters.
+  # The array is accepted in the format of Ruby
+  # method arguments --ie. [arg1, arg2, ..., hash]
+
+  def to_params
+    flags = (Hash===last ? pop : {})
+    flags = flags.collect do |f,v|
+      m = f.to_s.size == 1 ? '-' : '--'
+      case v
+      when Array
+        v.collect{ |e| "#{m}#{f} '#{e}'" }.join(' ')
+      when true
+        "#{m}#{f}"
+      when false, nil
+        ''
+      else
+        "#{m}#{f} '#{v}'"
+      end
+    end
+    return (flags + self).join(" ")
+  end
+
+  # Not empty?
+
+  def not_empty?
+    !empty?
+  end
+
+end
+
+
+class Hash
+
+  # Setup a console arguments vector from a set of config options.
+
+  def command_vector(args_field=nil)
+    config = dup
+    if args_field
+      args = [config.delete(args_field)].flatten.compact
+    else
+      args = []
+    end
+    args << config
+    return args
+  end
+
+end

data/lib/ratch/emailutils.rb

@@ -0,0 +1,88 @@
+begin
+  require 'facets/net/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+
+
+module Ratch
+
+  module EmailUtils
+
+    module_function
+
+    # 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.
+    #     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.
+    #
+    # (Square brackets indicate defaults taken from Project information.
+    # if used via Project class.)
+
+    def email(message, settings)
+      server    = settings['server']
+      account   = settings['account']
+      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
+
+    #def password( account )
+    #  @password || ENV['PASSWORD'] || ask("Password for #{account}: ")
+    #end
+
+  end
+
+end

data/lib/ratch/fileutils.rb

@@ -0,0 +1,173 @@
+require 'fileutils'
+
+
+module Ratch
+
+  module FileUtils
+
+    # Glob files.
+
+    def glob(*args, &blk)
+      Dir.glob(*args, &blk)
+    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
+
+    ##########################
+    # 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
+
+    # Delegate access to FileUtils.
+
+    def fileutils
+      dryrun? ? ::FileUtils::DryRun : ::FileUtils
+    end
+
+    # Bonus FileUtils features.
+
+    def cd(*a,&b)
+      puts "cd #{a}" if dryrun?
+      fileutils.chdir(*a,&b)
+    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
+
+    # 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
+
+    # 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 file a task?
+
+    def task?(path)
+      task = File.dirname($0) + "/#{path}"
+      task.chomp!('!')
+      task if FileTest.file?(task) && FileTest.executable?(task)
+    end
+
+    # Is a file a command executable?
+    #
+    # TODO Probably needs to be fixed for Windows.
+
+    def bin?(path)
+      is_bin = command_paths.any? do |f|
+        FileTest.exist?(File.join(f, path))
+      end
+      is_bin ? File.basename(path) : false
+    end
+
+    # This is a support method of #bin?
+
+    def command_paths
+      @command_paths ||= ENV['PATH'].split(':')
+    end
+
+    # TODO Make more robust.
+
+    UNSAFE = [ '/', '/*', '/**/*' ]
+
+    # Is a path considered reasonably "safe"?
+
+    def safe?(path)
+      case path
+      when *UNSAFE
+        return false
+      end
+      true
+    end
+
+  end
+end