ratch 0.3.0 → 0.4.0

data/lib/ratch/dsl/batch.rb

@@ -0,0 +1,226 @@
+# = TITLE:
+#
+#   Batch DSL
+#
+# = 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.
+#
+#   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'
+#require 'rbconfig'  # replace with facets/rbsystem in future ?
+
+#require 'ratch/dsl/batch/task'
+#require 'ratch/dsl/batch/build'
+#require 'ratch/dsl/batch/directory'
+
+module Ratch
+module Dsl
+
+  # Batch module defines the DSL for calling other batch files
+  # and system binaries.
+
+  module Batch
+
+    # Shell runner.
+
+    def sh(cmd)
+      if noharm?
+        puts cmd
+        true
+      else
+        puts "--> system call: #{cmd}" if trace?
+        system(cmd)
+      end
+    end
+
+    # Abort running.
+    #def abort(msg=nil)
+    #  puts msg if msg
+    #  exit 0
+    #end
+
+    def root_directory
+      @root_directory ||= Dir.pwd
+    end
+
+    def call_directory
+      @call_directory ||= File.expand_path(File.dirname($0))
+    end
+
+    # TODO Better name? Better definition?
+
+    def batch_directory
+      @batch_directory ||= (
+        dir = call_directory.sub(root_directory + '/', '').split('/').first
+        File.join(root_directory, dir)
+      )
+    end
+
+    # Current batch file, relative to the batch directory.
+
+    def batch_file
+      File.expand_path($0).sub(batch_directory + '/', '')
+    end
+
+    # Run batch file and cache result.
+    #
+    # Usually this can be taken care of by method_missing.
+    # But, in some cases, built in method names block batch
+    # calls, so you have to use #batch to invoke those.
+
+    def batch(batchfile, arguments=nil)
+      batch_cache[batchfile] ||= batch!(batchfile, arguments)
+    end
+
+    # Lauch a batch file. Like #batch but not-cached.
+    # Run a batch file.
+    # TODO: How to handle arguments?
+
+    def batch!(batchfile, arguments=nil)
+      #BatchFile.new(batchfile).call # Old way with batch execution context object.
+
+      @main = nil  # reset main task
+
+      script = File.read($0 = batchfile)
+      eval(script, TOPLEVEL_BINDING, $0)
+
+      #batch_file = File.expand_path($0).sub(batch_directory + '/', '')
+      #run(batch_file)
+      run_main #(batch_file)
+    end
+
+    # Is a path a local batch directory?
+
+    def batch_directory?(path)
+      b = File.join(File.dirname($0), path.to_s)
+      b if FileTest.directory?(b)
+    end
+
+    # Is a file a local batch file?
+
+    def batch?(path)
+      b = File.join(File.dirname($0), path.to_s)
+      b if FileTest.file?(b) && FileTest.executable?(b)
+    end
+
+    # Is a batch run complete or in the process of being completed?
+    # Has the batch file been executed before?
+
+    def done?(batchfile)
+      batchfile == $0 || batch_cache.key?(batchfile)
+    end
+
+    # Batch cache, which prevents batch runs from re-executing.
+
+    def batch_cache
+      @batch_cache ||= {}
+    end
+
+    # If method is missing try to run an external task
+    # or binary by that name. If it is a binary, arguments
+    # translate into commandline parameters. For example:
+    #
+    #   tar 'foo/', :x=>true, :v=>true, :z=>true, :f=>'foo.tar.gz'
+    #
+    # or
+    #
+    #   tar '-xvzf', "foo.tar.gz", "foo/"
+    #
+    # becomes
+    #
+    #   tar -x -v -z -f foo.tar.gz foo/
+    #
+    # If it is a task, it will be cached. Tasks only ever run once.
+    # To run them more than once you can manually execute them with #run.
+    # Likewise you can manually run and cache by calling #batch.
+    # This is good to know, b/c in some cases built in method names
+    # block task calls, so you have to #batch to invoke them.
+
+    def method_missing(sym,*args)
+      puts "method_missing: #{sym}" if debug?
+      #begin
+        launch(sym,*args)
+      #rescue ArgumentError
+      #  super
+      #end
+    end
+
+    # TODO Better name!!! Better code.
+
+    def launch(name, *args)
+      name  = name.to_s
+      force = name.chomp!('!')
+
+      # is this a batch directory?
+      if batch_directory?(name)
+        return Batch::Space.new(self, name)
+      end
+
+      params = args.to_params
+
+      # is this a batch file?
+      if bat = batch?(name)
+        if force
+          cmd = "./#{bat} #{params}"
+          puts "--> non-cached execution: #{cmd}" if trace?
+          return batch!(bat, args)
+        else
+          if done?(bat)
+            return nil unless bin?(name)  # return cache?
+          else
+            cmd = "./#{bat} #{params}"
+            puts "--> cached execution: #{cmd}" if trace?
+            return batch(bat, args)
+          end
+        end
+      end
+
+      # is this a bin file?
+      if bin = bin?(name)
+        cmd = "#{File.basename(bin)} #{params}"
+        return sh(cmd)
+      end
+
+      raise ArgumentError, "script not found -- #{name}"
+    end
+
+  end
+
+  # This is a type of functor, that allows for calling batch files
+  # that are in subdirectories using "dir.file" notation. Eg.
+  #
+  #   svn.log
+  #
+  # could run the svn/log ratch file.
+
+  class Batch::Space
+    private *instance_methods.select{ |m| m !~ /^__/ }
+
+    def initialize(manager, directory)
+      @manager   = manager
+      @directory = directory
+    end
+
+    def method_missing(sym, *args)
+      path = File.join(@directory, sym.to_s)
+      @manager.launch(path, *args)
+    end
+  end
+
+end
+end

data/lib/ratch/{batch → dsl}/build.rb

@@ -1,8 +1,8 @@
-# TITLE:
+# = TITLE:
 #
-#   Build
+#   Build DSL
 #
-# COPYING:
+# = COPYING:
 #
 #   Copyright (c) 2007 Psi T Corp.
 #
@@ -22,8 +22,86 @@
 #   along with Ratch.  If not, see <http://www.gnu.org/licenses/>.
 
 module Ratch
+module Dsl
 
-  # = Build class
+  module Builds
+
+    # Define a build target.
+
+    def file(name, &block)
+      name, deps, block = *parse_build_dependencies(name, &block)
+      define_file(name, *deps, &block)
+    end
+
+    # Build target(s).
+
+    def build(path)
+      # TODO How to handle more than one matching means of building?
+      #warn "More than one build definition matches #{path} using #{means.first}" if means.size > 1
+      if build = find_build(path)
+        if build.needed_for?(path) || force?
+          list, todo = *build_plan(build, path)
+          todo.each{|bld, pth| bld.call(pth) } #@builds[name].call }
+          build.call(path)
+        end
+      else
+        raise "build not found -- #{path}"
+      end
+    end
+
+    private
+
+      def builds; @builds ||= [] ; end
+
+      #
+      def parse_build_dependencies(name_deps, &block)
+        if Hash===name_deps
+          name = name_deps.keys[0]
+          deps = name_deps.values[0]
+        else
+          name = name_deps
+          deps = []
+        end
+        [name, deps, block]
+      end
+
+      # Define a file build task.
+
+      def define_file(name, *depend, &block)
+        build = Build::File.new(name, *depend, &block)
+        builds << build
+      end
+
+      #
+
+      def find_build(path)
+        builds.find{ |b| b.match?(path) }
+      end
+
+      # Prepare build plan, checking for circular dependencies.
+
+      def build_plan(build, path, list=[], todo=[])
+        #if list.include?(build)
+        #  raise "Circular build dependency #{build.name}."
+        #end
+
+        build.needed_paths.each do |npath|
+          next if list.include?(npath)
+          if nbuild = find_build(npath)
+            build_plan(nbuild, npath, list, todo)
+            todo << [nbuild, npath]
+          else
+            list << npath
+          end
+        end
+
+        return list, todo
+      end
+
+  end
+
+  # This class encapsulates the build procedure for creating
+  # a file (or directory).
 
   class Build
 
@@ -93,3 +171,4 @@ module Ratch
   end
 
 end
+end

data/lib/ratch/{batch/consoleutils.rb → dsl/console.rb}

@@ -1,8 +1,8 @@
-# TITLE:
+# = TITLE:
 #
-#   ConsoleUtils
+#   Console
 #
-# COPYING:
+# = COPYING:
 #
 #   Copyright (c) 2007 Psi T Corp.
 #
@@ -22,8 +22,9 @@
 #   along with Ratch.  If not, see <http://www.gnu.org/licenses/>.
 
 module Ratch
+module Dsl
 
-  module ConsoleUtils
+  module Console
 
     # Convenient method to get simple console reply.
 
@@ -55,10 +56,17 @@ module Ratch
       return inp.chomp
     end
 
+    # Internal status report.
+    # Only output if dryrun or trace mode.
+
+    def status(message)
+      puts message if dryrun? or trace?
+    end
+
   end
 
 end
-
+end
 
 class Array
 

data/lib/ratch/{batch/emailutils.rb → dsl/email.rb}

@@ -1,9 +1,8 @@
-
-# TITLE:
+# = TITLE:
 #
-#   EmailUtils
+#   Email DSL
 #
-# COPYING:
+# = COPYING:
 #
 #   Copyright (c) 2007 Psi T Corp.
 #
@@ -28,12 +27,10 @@ rescue LoadError
   require 'net/smtp'
 end
 
-
 module Ratch
+module Dsl
 
-  module EmailUtils
-
-    module_function
+  module Email
 
     # Email function to easily send out an email.
     #
@@ -45,24 +42,26 @@ module Ratch
     #     server       Email server to route message.
     #     port         Email server's port.
     #     domain       Email server's domain name.
-    #     account      Email account 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.
-    #
-    # (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
+      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
@@ -76,7 +75,7 @@ module Ratch
       raise ArgumentError, "missing email field -- to"      unless mail_to
       raise ArgumentError, "missing email field -- from"    unless mail_from
 
-      passwd = password(account)
+      passwd ||= password(account)
 
       mail_to = [mail_to].flatten.compact
 
@@ -103,10 +102,7 @@ module Ratch
       end
     end
 
-    #def password( account )
-    #  @password || ENV['PASSWORD'] || ask("Password for #{account}: ")
-    #end
-
   end
 
 end
+end

data/lib/ratch/{batch/fileutils.rb → dsl/file.rb}

@@ -1,8 +1,8 @@
-# TITLE:
+# = TITLE:
 #
-#   FileUtils
+#   File DSL
 #
-# COPYING:
+# = COPYING:
 #
 #   Copyright (c) 2007 Psi T Corp.
 #
@@ -25,22 +25,45 @@ require 'fileutils'
 require 'facets/dir/multiglob'
 require 'ratch/support/filetest'
 
+
 module Ratch
+module Dsl
 
-  module FileUtils
+  module Filing
 
-    # Glob files.
+    # Delegate access to FileUtils.
 
-    def glob(*args, &blk)
-      Dir.glob(*args, &blk)
+    def fileutils
+      dryrun? ? ::FileUtils::DryRun : ::FileUtils
     end
 
-    def multiglob(*args, &blk)
-      Dir.multiglob(*args, &blk)
+    # 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
 
-    def multiglob_r(*args, &blk)
-      Dir.multiglob_r(*args, &blk)
+    # 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
+
+    # Bonus FileUtils features.
+
+    def cd(*a,&b)
+      puts "cd #{a}" if dryrun? or trace?
+      fileutils.chdir(*a,&b)
     end
 
     # Read file.
@@ -59,45 +82,22 @@ module Ratch
       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.
+    # Assert that a path exists.
 
-    def cd(*a,&b)
-      puts "cd #{a}" if dryrun?
-      fileutils.chdir(*a,&b)
+    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.
 
-    #########################
-    # 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
-      }
+    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.
@@ -145,22 +145,20 @@ module Ratch
 #       abort "fold not found #{path}" unless paths.any?{|path| fold?(path)}
 #     end
 
-    # Assert that a path exists.
+    # Glob files.
 
-    def exists?(path)
-      paths = Dir.glob(path)
-      paths.not_empty?
+    def glob(*args, &blk)
+      Dir.glob(*args, &blk)
     end
-    alias_method :exist?, :exists? ; module_function :exist?
-    alias_method :path?,  :exists? ; module_function :path?
 
-    # Assert that a path exists.
+    def multiglob(*args, &blk)
+      Dir.multiglob(*args, &blk)
+    end
 
-    def exists!(*paths)
-      abort "path not found #{path}" unless paths.any?{|path| exists?(path)}
+    def multiglob_r(*args, &blk)
+      Dir.multiglob_r(*args, &blk)
     end
-    alias_method :exist!, :exists! ; module_function :exist!
-    alias_method :path!,  :exists! ; module_function :path!
+
 
 #     # Is a file a task?
 #
@@ -202,4 +200,6 @@ module Ratch
 #     end
 
   end
+
+end
 end