ratch 0.4.1 → 1.0.0

data/lib/ratch/dsl/stage.rb

@@ -1,147 +0,0 @@
-# = TITLE:
-#
-#   Stage DSL
-#
-# = 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 Ratch
-module Dsl
-
-  # Stage package by hard linking included files to a stage directory.
-
-  module Stage
-
-    # Stage package.
-    #
-    #   stage       Stage directory.
-    #   filelist    Files to link to stage.
-
-    def stage(stage, filelist)
-      stage_link(stage, filelist)
-      stage_manifest(stage)
-      return stage
-    end
-
-    # Prepare stage directory.
-
-    def stage_link(stage_directory, files)
-      return stage_directory if dryrun?           # Don't link to stage if dryrun.
-
-      stage_clear(stage_directory)
-      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
-
-    # Clear old stage, if any.
-
-    def stage_clear(stage_directory)
-      if File.directory?(stage_directory)         # Ensure existance of staging area
-        #raise(OverwriteError, stage_directory) unless force?
-        rm_r(stage_directory)
-      end
-    end
-
-    # Create manifest for stage directory.
-    # TODO Do this programatically rather then via shell.
-
-    def stage_manifest(stage_directory)
-      #cd(stage_directory) do
-      #  sh 'manifest up'
-      #end
-    end
-
-  end
-
-end
-end
-
-
-
-
-
-#
-#     # Build packages.
-#     # TODO Move this to Manager ?
-#
-#     def generate_packages
-#       package_files = formats.collect do |format|
-#         #format = clean_type(format)
-#         say '' if format == 'gem'  # FIXME This is here b/c Gems outputs on it's own.
-#         file = create_package(format)
-#         unless dryrun? or (format == 'gem')
-#           report_package_built(format, file) if file
-#         end
-#         file
-#       end
-#       report_packaging_complete(package_files.size)
-#     end
-#
-#     # Create package.
-#
-#     def create_package(type)
-#       package.format = type
-#
-#       builder_class = FormatBuilder.registry[type]
-#       builder = builder_class.new(package, stage_directory, options)
-#       file    = builder.build
-#
-#       transfer(file) unless dryrun?
-#
-#       return file
-#     end
-#
-#     # Transfer package file to storage dir.
-#
-#     def transfer(file)
-#       dest = File.join(store, File.basename(file))    # move to store, unless already there
-#       dest = File.expand_path(dest)
-#       mv(file, store) unless file == dest
-#     end
-#
-#     # Report that a package has been built.
-#
-#     def report_package_built(type, file)
-#       r = ''
-#       r << "\n  Successfully built #{type}"
-#       r << "\n  Name: #{package.name}"
-#       r << "\n  Version: #{package.version}"
-#       r << "\n  File: #{File.basename(file)}"
-#       say r
-#     end
-#
-#     # Report that packaging is complete.
-#
-#     def report_packaging_complete(size)
-#       say "\nSuccessfully built #{size} packages at #{store}/."
-#     end

data/lib/ratch/dsl/task.rb

@@ -1,139 +0,0 @@
-# = TITLE:
-#
-#   Task 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/>.
-
-module Ratch
-module Dsl
-
-  module Tasks
-
-    # 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)
-      task_plan(name).each{ |name| tasks[name].call }
-    end
-
-    private
-
-      def tasks ; @tasks ||= {} ; end
-
-      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.
-      #--
-      # TODO If @main is nil try task by same name a file (?)
-      #      If so, be careful of infinite loop via method_missing.
-      #++
-
-      def run_main
-        return unless main_task
-        run(main_task.name)
-      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
-
-  end
-
-  # Task is a very simple store for defined actions
-  # and their prerequisites.
-
-  class Task
-    attr_reader :name, :needs, :action
-
-    def initialize(name, *needs, &action)
-      @name          = name.to_s
-      @needs         = needs
-      @action        = action
-    end
-
-    def call
-      @action.call if @action
-    end
-  end
-
-end
-end

data/lib/ratch/dsl/upload.rb

@@ -1,436 +0,0 @@
-# = TITLE:
-#
-#   Upload 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/>.
-#
-# = TODO:
-#
-#   - Incorporate password into scp and ftp ?
-#   - rsync needs --delete option
-
-require 'openssl'
-require 'shellwords'
-require 'tmpdir'
-
-require 'facets/openobject'
-
-module Ratch
-module Dsl
-
-  # Upload files to host. These means of uploading are current
-  # supported: ftp, sftp, scp and rsync.
-  #
-  #     user       Username for host.
-  #     host       Host server's domain name.
-  #     root       Document root path on host.
-  #     copy       Directory of files to publish, or
-  #                Files to publish using from and to.
-  #
-  #     dryrun     If true only pretend to upload.
-  #     quiet      Supress all output.
-  #     verbose    Provide extra details.
-  #
-  # The copy parameter allows you to simply specify a file
-  # or directory which will be published to host's document
-  # root location.
-  #
-  # If you need more control over which files to publish
-  # where, you can use the copy parameter instead. Provide
-  # an array of pattern strings in the form of "{from} {to}".
-  # If the desitination is the host's document root you do
-  # not need to specify the {to} part. For example:
-  #
-  #     copy = [ 'web/*', 'doc/api/* doc/api' ]
-  #
-  # The first copies the files under your project's web directory
-  # to the host's document root. The second copies your projects
-  # doc/api files to the doc/api location on the host.
-  #
-  # The internal template used for the outbound destination
-  # is 'username@host:root/'.
-
-  module Upload
-
-    module_function
-
-    #
-    # Upload via given protocol.
-    #
-
-    def upload( protocol, opts )
-      send(protocol.to_s.downcase,opts)
-    end
-
-    #
-    # Use ftp to upload files.
-    #
-
-    def ftp( keys )
-      keys = upload_parameters(keys)
-
-      # set transfer rules
-      if keys.stage
-        trans = stage_transfer(keys.stage)
-      else
-        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
-        require 'net/ftp'
-        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 = stage_transfer(keys.stage)
-      else
-        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
-        require 'net/sftp'
-        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
-
-    #
-    # Use rsync to upload files.
-    #
-
-    def rsync( keys )
-      keys = upload_parameters(keys)
-
-      flags = []
-      flags << "-n" if keys.dryrun
-      flags << "-q" if keys.quiet
-      flags << "-v" if keys.verbose
-      flags << "--progress" unless keys.quiet
-      flags = flags.join(' ').strip
-      flags = ' ' + flags unless flags.empty?
-
-      manfile = 'Publish.txt'
-
-      if keys.stage
-        dir = stage_linkdir(keys.dir, keys.stage)
-        Dir.chdir(dir) do
-          cpy = files(keys.copy)
-        end
-        manifest = File.join(dir,manfile)
-        cmd = %{rsync#{flags} -L -arz --files-from='#{manifest}' #{dir} #{keys.user}@#{keys.host}:/#{keys.root}}
-      else
-        dir = keys.dir
-        cpy = files(dir, keys.copy)
-        manifest = File.join(dir,manfile)
-        cmd = %{rsync#{flags} -arz --files-from='#{manifest}' #{dir} #{keys.user}@#{keys.host}:/#{keys.root}}
-      end
-
-      #Dir.chdir(keys.dir) do
-        begin
-          File.open(manifest, 'w'){ |f| f << cpy.join("\n") }
-          ENV['RSYNC_PASSWORD'] = keys.pass if keys.pass
-          puts cmd unless keys.quiet
-          system cmd
-        ensure
-          ENV.delete('RSYNC_PASSWORD') if keys.pass
-        end
-      #end
-
-    end
-
-    # private (can't do b/c of module_function)
-
-    # parse publishing options.
-
-    def upload_parameters( keys )
-      keys = OpenObject.new(keys)
-
-      keys.copy = keys.copy || '**/*'
-      keys.host = keys.host || keys.domain
-      keys.user = keys.user || keys.username
-      keys.root = keys.root || '/'
-      #keys.pass = keys.pass || keys.password
-
-      # validate
-      raise ArgumentError, "missing publish parameter -- dir" unless keys.dir
-      raise ArgumentError, "missing publish parameter -- host" unless keys.host
-      raise ArgumentError, "missing publish parameter -- user" unless keys.user
-      #raise ArgumentError, "missing publish parameter -- copy" unless keys.copy
-      #raise ArgumentError, "missing publish parameter -- root" unless keys.root
-
-      keys.root = '' if keys.root.nil?
-      keys.root.sub!(/^\//,'')
-
-      if String===keys.copy and File.directory?(keys.copy)
-        copy = File.join(keys.copy, '*')
-      end
-      keys.copy = [keys.copy].flatten.compact
-
-  #     trans = []
-  #     keys.copy.each do |from|
-  #       #from, to = *Shellwords.shellwords(c)
-  #       #to = from if to.nil?
-  #       #to = to[1..-1] if to[0,1] == '/'
-  #       from.sub('*','**/*') unless from =~ /\*\*/
-  #       files = Dir.glob(from)
-  #       files.each do |f|
-  #         #t = File.join(to,File.basename(f))
-  #         #t = t[1..-1] if t[0,1] == '/'
-  #         trans << [f,f]
-  #       end
-  #     end
-  #     keys.trans = trans
-
-      return keys
-    end
-
-    # Put together the list of files to copy.
-
-    def 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)
-
-        files = []
-        add.each{ |g| files += Dir.multiglob(g) }
-        del.each{ |g| files -= Dir.multiglob(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 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
-
-    # When using stage options this will create temporary linked location.
-
-    def stage_linkdir( dir, list )
-      folder = File.join(Dir.tmpdir, 'ratchets', 'project', object_id.abs.to_s)
-      FileUtils.mkdir_p(folder)
-
-      Dir.chdir(dir) do
-        stage_transfer(list).each do |file, to|
-          link = File.join(folder,to)
-          FileUtils.ln_s(link,file)
-        end
-      end
-
-      return folder
-    end
-
-  end
-
-end
-end
-
-
-=begin
-
-
-  #--
-  # SHELLS OUT! Need net/scp library to fix.
-  #++
-
-  # Use scp to upload files.
-
-  def scp( keys )
-    keys = upload_parameters(keys)
-
-    flags = []
-    flags << "-v" if keys.verbose
-    flags << "-q" if keys.quiet
-    flags = flags.join(' ').strip
-    flags = ' ' + flags unless flags.empty?
-
-    upload_stage(keys) do #|tmpdir|
-      cmd = "scp -r#{flags} * #{keys.user}@#{keys.host}:/#{keys.root}"
-      puts cmd unless keys.quiet
-      system cmd unless keys.dryrun
-    end
-  end
-
-  # Use rsync to upload files.
-
-  def rsync( keys )
-    keys = upload_parameters(keys)
-
-    flags = []
-    flags << "-n" if keys.dryrun
-    flags << "-v" if keys.verbose
-    flags << "-q" if keys.quiet
-    flags = flags.join(' ').strip
-    flags = ' ' + flags unless flags.empty?
-
-    upload_stage(keys) do #|tmpdir|
-      begin
-        ENV['RSYNC_PASSWORD'] = keys.pass if keys.pass
-        cmd = "rsync -R#{flags} -arz * #{keys.user}@#{keys.host} /#{keys.root}"
-      ensure
-        ENV.delete('RSYNC_PASSWORD') if keys.pass
-      end
-    end
-  end
-
-  # Use ftp to upload files.
-
-  def ftp( keys )
-    keys = upload_parameters(keys)
-
-    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
-      require 'net/ftp'
-      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)
-
-    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
-      require 'net/sftp'
-      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
-
-
-  # Creates a stage from which the whole directory can be uploaded.
-  # This is needed for scp and rsync which have to shelled out,
-  # and can't conveniently copy one file at a time.
-
-  def upload_stage(keys) #:yield:
-    tmp = "scp_#{object_id.abs}_#{ Time.now.strftime("%Y%m%d%H%M%S")}"
-    tmpdir = File.join(Dir.tmpdir,tmp)
-
-    puts "mkdir -p #{tmpdir}" unless keys.quiet
-    FileUtils.mkdir_p(tmpdir)  # go ahead and do this even if dryrun
-
-    fu = keys.dryrun ? FileUtils::DryRun : FileUtils
-    keys.trans.each do |f, t|
-      to = File.join(tmpdir, t)
-      fu.mv(f,to)
-    end
-
-    puts "cd #{tmpdir}" unless keys.quiet
-    Dir.chdir(tmpdir) do
-      yield #(tmpdir)
-    end
-
-    puts "rm -r #{tmpdir}" unless keys.quiet
-    FileUtils.rm_r(tmpdir)  # now remove the temp dir
-  end
-
-=end