ratch 0.3.0 → 0.4.0

data/lib/ratch/batch.rb

@@ -1,488 +0,0 @@
-# = TITLE:
-#
-#   BatchFile
-#
-# = 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 'shellwords'
-require 'yaml'
-require 'rbconfig'  # replace with facets/rbsystem in future ?
-#require 'facets/hash/merge'  # for reverse_merge
-
-require 'ratch/batch/options'
-
-require 'ratch/batch/consoleutils'
-require 'ratch/batch/configutils'
-require 'ratch/batch/emailutils'
-require 'ratch/batch/fileutils'
-require 'ratch/batch/argvutils'
-
-require 'ratch/batch/task'
-require 'ratch/batch/build'
-
-
-module Ratch
-
-  # If no batch file is found.
-
-  class NoBatchError < Exception
-  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 BatchDirectory
-    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.open_batch(path, *args)
-    end
-  end
-
-  # BatchScript module defines the DSL available to a ratch script.
-
-  module BatchScript #< Module
-
-    include GeneralOptions
-    include ConsoleUtils
-    include ArgvUtils
-    include FileUtils
-    include ConfigUtils
-    include EmailUtils
-
-    # 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? (Won't handle task subdirs!).
-
-    def batch_directory
-      @batch_directory ||= (
-        dir = call_directory.sub(root_directory + '/', '').split('/').first
-        File.join(root_directory, dir)
-      )
-    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] ||= launch(batchfile, arguments)
-    end
-
-    # Lauch a batch file. Like #batch but not-cached.
-    # Run a batch file.
-    # TODO: How to handle arguments?
-
-    def launch(batchfile, arguments=nil)
-      # # TODO probably should raise error instead
-      # abort "missing batch file -- #{batchfile}" unless File.file?(batchfile)
-
-      #BatchFile.new(batchfile).call # Old way with batch execution context object.
-      script = File.read($0 = batchfile)
-      #eval(script, $batch_binding, $0)
-      eval(script, TOPLEVEL_BINDING, $0)
-
-      batch_file = File.expand_path($0).sub(batch_directory + '/', '')
-      call_task(batch_file)
-    end
-
-    # Is a path a local batch directory?
-
-    def batch_directory?(path)
-      b = File.dirname($0) + "/#{path}"
-      b if FileTest.directory?(b)
-    end
-
-    # Is a file a local batch file?
-
-    def batch?(path)
-      b = File.dirname($0) + "/#{path}" #.chomp!('!')
-      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
-        open_batch(sym,*args)
-      #rescue NoBatchError
-      #  super
-      #end
-    end
-
-    private
-
-      #
-
-      def open_batch(name, *args)
-        name  = name.to_s
-        force = name.chomp!('!')
-
-        # is this a batch directory?
-        if dir = batch_directory?(name)
-          return BatchDirectory.new(self, dir)
-        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 launch(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 NoBatchError, "no extecutable file found -- #{name}"
-      end
-
-    public
-
-    # Define main task.
-
-    def main(name, &block)
-      name, deps, block = *parse_task_dependencies(name, &block)
-      define_main(name, *deps, &block)
-    end
-
-    # Define a task.
-
-    def task(name, &block)
-      name, deps, block = *parse_task_dependencies(name, &block)
-      define_task(name, *deps, &block)
-    end
-
-    # Run a task.
-
-    def run(name, arguments=nil)
-      call_task(name)
-    end
-
-    private
-
-      def tasks ; @tasks ||= {} ; end
-
-      # TODO If @main is nil try task by same name a file (?)
-
-      def main_task
-        @main
-      end
-
-      #
-
-      def parse_task_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
-
-      def define_main(name=nil, *depend, &block)
-        @main = define_task(name, *depend, &block)
-        #@main = Task.new(name, *depend, &block)
-        #tasks[@main.name] = @main
-      end
-
-      def define_task(name, *depend, &block)
-        task = Task.new(name, *depend, &block)
-        tasks[task.name] = task
-      end
-
-      # Call main task.
-
-      def call_main #(task=nil)
-        #@main ||= task
-        #return unless @main || task
-        call_task(main_task.name)
-      end
-
-      # Call task.
-
-      def call_task(name)
-        task_plan(name).each{ |name| tasks[name].call }
-      end
-
-      # Prepare plan, checking for circular dependencies.
-
-      def task_plan(name, list=[])
-        if list.include?(name)
-          raise "Circular dependency #{name}."
-        end
-        if task = tasks[name]
-          task.needs.each do |need|
-            need = need.to_s
-            next if list.include?(need)
-            #@tasks[need].task_plan(need, list)
-            task_plan(need, list)
-          end
-          list << task.name
-        else
-          # TODO THIS TIES TASKS INTO BATCH, BETTER WAY?
-          if name != main_task && fname = batch?(name)
-            task = Task.new(name) do
-              batch(fname)
-            end
-            tasks[name] = task
-            list << task.name
-          else
-            abort "no task -- #{name}"
-          end
-        end
-        return list
-      end
-
-    public
-
-    # 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(file)
-      call_build(file)
-    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.new(name, *depend, &block)
-        builds << build
-      end
-
-      # Call build.
-
-      def call_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(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
-
-      def find(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(npath)
-            build_plan(nbuild, npath, list, todo)
-            todo << [nbuild, npath]
-          else
-            list << npath
-          end
-        end
-
-        return list, todo
-      end
-
-
-# OLD WAY
-#   def method_missing(sym,*args)
-#       name = sym.to_s
-#
-#       bat   = batch?(name)                          # is this a batch file?
-#       done  = bat && done?(bat)
-#       cache = bat && !done && name[1,-1] != '!'
-#       bin   = bin?(name) if (!bat || done)
-#       none  = bat && done && !bin
-#       #bat  = name if bin
-#
-#       return super unless bat || bin
-#
-#       return if none  # nothing to do
-#
-#       params = args.to_params
-#
-#       if bin
-#         cmd = "#{File.basename(bin)} #{params}"
-#         res = sh(cmd)
-#       elsif bat
-#         cmd = "./#{bat} #{params}"
-#         puts "--> #{cache ? '' : 'not-'}cached execution: #{cmd}" if trace?
-#         res = batch(bat, args)
-#         if cache
-#           #@batch_catch[bat] ||= (system(cmd); true)
-#           #batch_cache[bat] ||= res
-#           batch_manager.cache ||= res
-#         end
-#       end
-#
-#       return res
-
-
-    # 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
-    #    call_main
-    #    #run(:main) if task_manager.main
-    #  end
-
-  end
-
-end
-
-# Load BatchScript into to toplevel.
-#
-# TODO: Should this be in all Object space (ie. no class << self)?
-
-class << self
-  include Ratch::BatchScript
-end
-
-END {
-  #task = File.expand_path($0).sub(batch_directory + '/', '')
-  call_main #(task)
-}
-
-#$batch_binding = binding

data/lib/ratch/support/setuputils.rb

@@ -1,124 +0,0 @@
-# FILE:
-#
-#   setup.rb
-#
-# SUMMARY:
-#
-#   Mixen used to setup a package, eg. a manual install.
-#
-# COPYING:
-#
-#   Copyright (c) 2007 Psi T Corp.
-#
-#   This file is part of the ProUtils' Box program.
-#
-#   Box 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.
-#
-#   Box 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 Box.  If not, see <http://www.gnu.org/licenses/>.
-
-#
-module Box
-
-  # = setup utilties
-  #
-  # Setup utilities provides a convenient way to install
-  # a ruby project via setup.rb.
-
-  module SetupUtils
-
-    # If setup.rb is not found add a copy to the project.
-
-    def setup_rb
-      unless File.exist?('setup.rb')
-        f = File.join(libdir,'vendor','setup.rb')
-        if File.exist?(f)
-          cp(f,'.')
-        else
-          abort "setup.rb is not avaialble"
-        end
-      end
-      true
-    end
-
-    # Installation to a prefix destination using setup.rb.
-    # Some package types need this.
-
-    def prefix_install( prefix )
-      FileUtils.mkdir_p( prefix )
-      Dir.chdir( folder ) do
-        unless setup_rb
-          raise "Setup.rb is missing. Forced to abort."
-        end
-        # mock install
-        cmd = ''
-        cmd << 'ruby setup.rb '
-        cmd << '-q ' unless project.verbose?
-        cmd << 'config --installdirs=std ; '
-        cmd << 'ruby setup.rb '
-        cmd << '-q ' unless project.verbose?
-        cmd << "install --prefix=#{prefix}"
-        sh cmd
-      end
-    end
-
-    # Setup and install. This builds and installs a project
-    # using setup.rb or install.rb. If neither exist setup.rb
-    # will be created for the purpose.
-    #
-    #     options    Command line options to add to shell command.
-    #     script     Install script, default is install.rb or setup.rb
-    #--
-    #     source     Location of source. (Defaults to current directory)
-    #++
-
-    def setup( keys={} )
-      #keys |= project.select(:options=>:setup_options, :script=>:setup_script)
-
-      options = keys['options']
-      script  = keys['script']
-      #source = keys.source || Dir.pwd
-
-      options = [options].flatten.compact
-
-      if script
-        exe = script + ' '
-        exe << options.join(' ')
-      elsif File.exist?('install.rb')
-        exe = 'ruby install.rb '
-        exe << options.join(' ')
-      elsif File.exist?('setup.rb') or setup_rb
-        exe = 'ruby setup.rb '
-        exe << '-q ' unless project.verbose?
-        exe << options.join(' ')
-        exe << ' all'
-      else
-        puts "Script setup.rb or install.rb is missing."
-        return nil
-      end
-
-      # SHELLS OUT!
-
-      #Dir.chdir(source) do
-        #begin
-          success = sh( exe )
-          puts "Installation complete!" if success
-        #rescue Errno::EACCES
-        #  puts "Permission denied"
-        #  exit -1
-        #end
-      #end
-    end
-
-  end
-
-end
-