ratch 1.1.0 → 1.2.0

data/lib/ratch/task2.rb

@@ -1,298 +0,0 @@
-module Taskable
-
-  def self.define_task(base, target_and_requisite, &function)
-    case base
-    when Class, Module
-
-    else #Object
-
-    end
-  end
-
-
-  module ClassDSL
-    # Without an argument, returns list of tasks defined for this class.
-    #
-    # If a task's target name is given, will return the first
-    # task mathing the name found in the class' inheritance chain.
-    # This is important ot ensure task are inherited in the same manner
-    # that methods are.
-    def tasks(target=nil)
-      if target
-        target = target.to_sym
-        anc = ancestors.select{|a| a < DSL}
-        t = nil; anc.find{|a| t = a.tasks[target]}
-        return t
-      else
-        @tasks ||= {}
-      end
-    end
-
-    # Set a description to be used by then next defined task in this class.
-    def desc(description)
-      @desc = description
-    end
-
-    # Define a task.
-    def task(target_and_requisite, &function)
-      target, requisite, function = *Task.parse_arguments(target_and_requisite, &function)
-      task = tasks[target.to_sym] ||= (
-        tdesc = @desc
-        @desc = nil
-        Task.new(self, target, tdesc) #, reqs, actions)
-      )
-      task.update(requisite, &function)
-
-      define_method("#{target}Trigger"){ task.run(self) }
-      define_method("#{target}:task", &function)
-    end
-
-  end
-
-  #
-  module ObjectDSL
-
-    # Without an argument, returns list of tasks defined for this class.
-    #
-    # If a task's target name is given, will return the first
-    # task mathing the name found in the class' inheritance chain.
-    # This is important ot ensure task are inherited in the same manner
-    # that methods are.
-    def tasks(target=nil)
-      if target
-        target = target.to_sym
-        anc = ancestors.select{|a| a < DSL}
-        t = nil; anc.find{|a| t = a.tasks[target]}
-        return t
-      else
-        @tasks ||= {}
-      end
-    end
-
-    # Set a description to be used by then next defined task in this class.
-    def desc(description)
-      @desc = description
-    end
-
-    # Define a task.
-    def task(target_and_requisite, &function)
-      target, requisite, function = *Task.parse_arguments(target_and_requisite, &function)
-      task = tasks[target.to_sym] ||= (
-        tdesc = @desc
-        @desc = nil
-        Task.new(self, target, tdesc) #, reqs, actions)
-      )
-      task.update(requisite, &function)
-
-      define_method("#{target}Trigger"){ task.run(self) }
-      define_method("#{target}:task", &function)
-    end
-
-  end
-
-
-
-  # Run a task.
-  #def run(target)
-  #  t = self.class.tasks(target)
-  #  t.run(self)
-  #end
-
-  # = Task Class
-  #
-  class Task
-    attr :base
-    attr :target
-    attr :requisite
-    attr :function
-    attr :description
-
-    def initialize(base, target, description=nil, requisite=nil, &function)
-      @base        = base
-      @target      = target.to_sym
-      @description = description
-      @requisite   = requisite || []
-      @function    = function
-    end
-
-    #
-    def update(requisite, &function)
-      @requisite.concat(requisite).uniq!
-      @function = function if function
-    end
-
-    #
-    def prerequisite
-      base.ancestors.select{ |a| a < DSL }.collect{ |a|
-        a.tasks[target].requisite
-      }.flatten.uniq
-    end
-
-    # invoke target
-    def run(object)
-      rd = rule_dag
-      rd.each do |t|
-        object.send("#{t}:task")
-      end
-    end
-
-    #
-    def call(object)
-      object.instance_eval(&function)
-    end
-
-    # Collect task dependencies for running.
-    def rule_dag(cache=[])
-      prerequisite.each do |r|
-        next if cache.include?(r)
-        t = base.tasks[r]
-        t.rule_dag(cache)
-        #cache << dep
-      end
-      cache << target.to_s
-      cache
-    end
-
-    #
-    def self.parse_arguments(name_and_reqs, &action)
-      if Hash===name_and_reqs
-        target = name_and_reqs.keys.first.to_s
-        reqs = [name_and_reqs.values.first].flatten
-      else
-        target = name_and_reqs.to_s
-        reqs = []
-      end
-      return target, reqs, action
-    end
-  end
-
-  # = File Task Class
-  #
-  class FileTask < Task
-
-    def needed?
-      if prerequisite.empty?
-        dated = true
-      elsif File.exist?(target)
-        mtime = File.mtime(target)
-        dated = prerequisite.find do |file|
-          !File.exist?(file) || File.mtime(file) > mtime
-        end
-      else
-        dated = true
-      end
-      return dated
-    end
-
-    #
-    def call(object)
-      object.instance_eval(&function) if needed?
-    end
-  end
-
-end
-
-
-=begin
-    # turn yaml file into tasks
-    def parse(file)
-      script = YAML.load(File.new(file.to_s))
-
-      imports = script.delete('import')   || []
-      #plugins = script.delete('plugin')   || []
-      srvs    = script.delete('services') || {}
-      tgts    = script.delete('targets')  || {}
-
-      imports.each do |import|
-        path = Reap::Domain::LIB_DIRECTORY + 'systems' + (import + '.reap').to_s
-        parse(path)
-      end
-
-      srvs.each do |label, options|
-        type = options.delete('type')
-        @services[label] = domain.send("#{type}_service")  # FIXME
-      end
-
-      tgts.each do |target, options|
-        @targets[target] = Task.new(self, target, options)
-      end
-    end
-=end
-
-
-
-
-
-
-=begin
-    # Collect task dependencies for running.
-    def self.rule_dag(target, cache=[])
-      t = tasks[target.to_sym]
-      d = t.prerequisite
-      d.each do |r|
-        next if cache.include?(r)
-        rule_dag(r, cache)
-        #cache << dep
-      end
-
-      # file requirements
-      #q = self.class.ann(name, :reqs) || []
-      #q.each do |req|
-      #  path = Pathname.new(req)
-      #  next if r.include?(path)
-      #  mat = annotations.select{ |n, a| File.fnmatch?(a[:file].first, req) if a[:file] }.compact
-      #  mat.each do |n, a|
-      #    rule_dag(n, r)
-      #  end
-      #  r << path
-      #end
-
-      cache << target.to_s
-      return cache
-    end
-
-    # invoke target
-    def run(target)
-      target = target.to_sym
-      rd = self.class.rule_dag(target)
-      rd.each do |t|
-        send("#{t}:task")
-      end
-    end
-=end
-
-=begin
-        if target == name.to_s
-          tasks[target].call
-        else
-          case action
-          when Pathname
-            raise unless action.exist?
-          else
-            run_rec(action)
-          end
-        end
-      end
-    end
-
-    def run_rec(action)
-      # creates a file?
-      dated = true
-      if creates = self.class.ann(action, :file)
-        if self.class.ann(name, :reqs).empty?
-          dated = true
-        elsif File.exist?(creates)
-          mtime = File.mtime(creates)
-          dated = self.class.ann(name, :reqs).find do |file|
-            !File.exist?(file) || File.mtime(file) > mtime
-          end
-        else
-          dated = true
-        end
-      end
-      return unless dated
-      send(action)
-    end
-=end
-
-

data/meta/abstract

@@ -1,4 +0,0 @@
-Ratch is a Ruby-based batch scripting language.
-It's a DSL over regular RUby to make the life
-of the batch script writter easier.
-

data/meta/author

@@ -1 +0,0 @@
-trans <transfire@gmail.com>

data/meta/contact

@@ -1 +0,0 @@
-trans <transfire@gmail.com>

data/meta/homepage

@@ -1 +0,0 @@
-http://ratch.rubyforge.org

data/meta/name

@@ -1 +0,0 @@
-ratch

data/meta/requires

@@ -1,4 +0,0 @@
-facets
-folio
-clio
-

data/meta/summary

@@ -1 +0,0 @@
-Ruby-based Batch Scripting

data/test/README

@@ -1 +0,0 @@
-Yea. I needs to write test very badly.

data/test/test_helper.rb

@@ -1,4 +0,0 @@
-require 'test/unit'
-
-$LOAD_PATH.unshift('lib')
-

data/test/test_task.rb

@@ -1,46 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-require 'ratch/task'
-
-class TestTaskable < Test::Unit::TestCase
-
-  RESULT_CACHE = []
-
-  class Example #< Ratch::DSL 
-
-    include Taskable
-
-    task :task_with_no_requisites do
-      RESULT_CACHE << "task_with_no_requisites"
-    end
-
-    task :task_with_one_requisite => [:task_with_no_requisites] do
-      RESULT_CACHE << "task_with_one_requisite"
-    end
-
-  end
-
-
-  def setup
-    RESULT_CACHE.replace([])
-    @example = Example.new
-  end
-  
-  def teardown
-  end
-  
-  # Replace this with your real tests.
-  def test_task_with_no_requisite
-    @example.run :task_with_no_requisites
-    #@example.task_with_no_requisites_trigger
-    assert_equal(["task_with_no_requisites"], RESULT_CACHE)
-  end
-
-  def test_task_with_one_requisite
-    @example.run :task_with_one_requisite
-    #@example.task_with_one_requisite_trigger
-    assert_equal(["task_with_no_requisites", "task_with_one_requisite"], RESULT_CACHE)
-  end
-
-end
-