ratch 0.1 → 0.2.1

data/lib/ratch/argvutils.rb

@@ -0,0 +1,56 @@
+
+module Ratch
+
+  # No fuss access to ARGV. This shows up as #argv in the ratch api.
+  #
+  # Ratch uses '=' for parameterized flags b/c this make parsing stupid simple
+  # and that's a good thing!!!
+
+  module ArgvUtils
+
+    def argv
+      @argv ||= (ARGV.dup).extend(Ext)
+    end
+
+    module Ext
+
+      def flags
+        @flags ||= collect{ |e| e =~ /^-/ && e !~ /=/ }
+      end
+
+      def arguments
+        @arguments ||= collect{ |e| e !~ /=/ }
+      end
+
+      def parameters
+        @parameters ||= (
+          pms = {}
+          collect{ |e| e =~ /=/ }.each do |e|
+            pms.store(*split('='))
+          end
+          pms
+        )
+      end
+
+      # Does ARGV include a specifc flag?
+      def flag?(flag)
+        include?(flag)
+      end
+
+      # You can use this if you want to use parameterized
+      # flags w/o the '=', however be aware that the
+      # parameter value will also be listed amoung the
+      # bare arguments list. For example:
+      #
+      #   $ foo tom --say hello
+      #
+      #   argv.value('--say')  #=> "hello"
+      #   argv.arguments  #=> ["tom", "hello"]
+      #
+      def value(flag)
+        fetch(index(flag)+1)
+      end
+
+    end
+  end
+end

data/lib/ratch/batch.rb

@@ -1,6 +1,7 @@
 #require 'shellwords'
 require 'rbconfig'  # replace with facets/rbsystem in future ?
 require 'ratch/taskutils'
+require 'ratch/batchable'
 
 module Ratch
 
@@ -11,6 +12,9 @@ module Ratch
 
     include TaskUtils
 
+    include Batchable
+    include OpenBatchable
+
     # Quick start, equivalent to calling new.run(file).
 
     #def self.start(file)
@@ -29,7 +33,9 @@ module Ratch
     def call(arguments=nil)
       script = File.read($0 = @file)
       eval(script, binding, $0) #instance_eval(script)
-      @main.call if @main
+      #@main.call if @main
+      task_manager.call_main
+      #run(:main) if task_manager.main
     end
 
   end

data/lib/ratch/{runnable.rb → batchable.rb}

@@ -1,43 +1,66 @@
 module Ratch
 
-  #
+  class BatchManager
 
-  module Runnable
+    # Task cache, which prevents batch runs from re-executing.
+    attr :cache
 
-    # TODO How to handle arguments?
+    # New BatchManager.
+    def initialize
+      @cache = {}
+    end
 
+    #
+    def batch(batchfile, arguments=nil)
+      @cache[batchfile] ||= run(batchfile, arguments)
+    end
+
+    # TODO How to handle arguments?
     def run(batchfile, arguments=nil)
       BatchFile.new(batchfile).call
-#       # TODO probably should raise error instead
-#       abort "missing batch file -- #{batchfile}" unless File.file?(batchfile)
-#       script = File.read($0 = batchfile)
-#       #instance_eval(script)
-#       eval(script, binding, $0)
+      #       # TODO probably should raise error instead
+      #       abort "missing batch file -- #{batchfile}" unless File.file?(batchfile)
+      #       script = File.read($0 = batchfile)
+      #       #instance_eval(script)
+      #       eval(script, binding, $0)
+    end
+
+    #
+    def done?(batchfile)
+      batchfile == $0 or @cache.key?(batchfile)
+    end
+
+  end
+
+  #
+
+  module Batchable
+
+    # Reference batch manager.
+    def batch_manager
+      @batch_manager ||= BatchManager.new
     end
 
     # Batch run, ie. run and cache.
     # Usually this can be take care of by method_missing.
     # But, in some cases, built in method names block task
     # calls, so you have to use #batch to invoke those.
-
     def batch(batchfile, arguments=nil)
-      task_cache[task] ||= run(batchfile, arguments)
+      batch_manager.batch(batchfile, arguments=nil)  # why did I have task instead of batchfile before?
     end
 
-    # Task cache, which prevents batch runs from re-executing.
-
-    def task_cache
-      @@task_cache ||= {}
+    # Lauch a batch file (non-cached)
+    def launch(batchfile, arguments=nil)
+      batch_manager.run(batchfile, arguments=nil)
     end
 
-    # Is a task complete or in the process of being completed?
-
-    def done?(task)
-      task == $0 or task_cache.key?(task)
+    # Is a batch run complete or in the process of being completed?
+    def done?(batchfile)
+      batch_manager.done?(batchfile)
     end
 
     # Shell runner.
-
+    # TODO Does this belong here?
     def sh(cmd)
       if noharm?
         puts cmd
@@ -49,16 +72,15 @@ module Ratch
     end
 
     # Abort running.
-
-    def abort(msg=nil)
-      puts msg if msg
-      exit 0
-    end
+    #def abort(msg=nil)
+    #  puts msg if msg
+    #  exit 0
+    #end
 
   end
 
   #
-  module OpenRunnable
+  module OpenBatchable
 
     # If method is missing try to run an external task
     # or binary by that name. If it is a binary, arguments
@@ -106,8 +128,8 @@ module Ratch
         puts "--> #{cache ? '' : 'not-'}cached execution: #{cmd}" if trace?
         res = run(task, args)
         if cache
-          #@task_cache[task] ||= (system(cmd); true)
-          task_cache[task] ||= res
+          #@batch_catch[task] ||= (system(cmd); true)
+          batch_catch[task] ||= res
         end
       end
 

data/lib/ratch/buildable.rb

@@ -0,0 +1,107 @@
+module Ratch
+
+  # = Buildable mixin
+  #
+  module Buildable
+
+    # Reference task manager.
+    def build_manager
+      @build_manager ||= BuildManager.new
+    end
+
+    # Define a build target.
+    def file(name, &block)
+      name, deps, block = *parse_build_dependencies(name, &block)
+      @build_manager.define_file(name, *deps, &block)
+    end
+
+    # Build a file.
+    def build(file)
+      @build_manager.call(file)
+    end
+
+    private
+
+      #
+      def parse_build_dependencies
+        if Hash===name_deps
+          name = name_deps.keys[0]
+          deps = name_deps.values[0]
+        else
+          name = name_deps
+          deps = []
+        end
+        [name, *deps, &block]
+      end
+  end
+
+  # = BuildManager class
+  #
+  class BuildManager
+    attr :builds
+
+    def initialize
+      @builds = {}
+    end
+
+    def define_file(name, *depend, &block)
+      build = Build.new(name, *depend, &block)
+      builds[build.name] = task
+    end
+
+    #
+    def call(file)
+      plan.each{ |name| @@tasks[name].action_call }
+      #action_call
+    end
+
+    # TODO Check for circular dependencies.
+    def plan(list=[])
+      if list.include?(name)
+        raise "Circular dependency #{name}."
+      end
+      @preqs.each do |need|
+        need = need.to_s
+        next if list.include?(need)
+        @@tasks[need].plan(list)
+      end
+      list << name
+      return list
+    end
+
+  end
+
+  # = Build class
+  #
+  class Build
+
+    attr :name
+    attr :preqs
+    attr :action
+
+    #
+    def initialize(name, *preqs, &action)
+      @name          = name.to_s
+      @preqs         = preqs
+      @action        = action
+    end
+
+    #
+    def call
+      files = Dir.glob(@name)
+      files.each do |name|
+        if File.exist?(name)
+          mtime = File.mtime(name)
+          needs = @preqs.find do |file| 
+            !File.exist?(file) || File.mtime(file) > mtime
+          end
+        else
+          needs = true
+        end
+        @action.call(@name) if needs
+      end
+    end
+
+  end
+end
+

data/lib/ratch/options.rb

@@ -5,7 +5,7 @@ module Ratch
 
   module GeneralOptions
 
-    #
+    # Duplicate of ARGV.
 
     def argv
       @argv ||= ARGV.dup

data/lib/ratch/taskable.rb

@@ -1,105 +1,115 @@
 module Ratch
 
+  # = Taskable Mixin
+  #
   module Taskable
 
-    #def main
-    #  @main
-    #end
-
-    def tasks
-      @tasks ||= {}
+    # Reference task manager.
+    def task_manager
+      @task_manager ||= TaskManager.new
     end
 
     # Define a main task.
-
     def main(name, &block)
-      @main = Task.register(name, &block)
-      tasks[@main.name] = @main
+      name, deps, block = *parse_task_dependencies(name, &block)
+      task_manager.define_main(name, *deps, &block)
     end
 
     # Define a task.
-
     def task(name, &block)
-      tsk = Task.register(name, &block)
-      tasks[tsk.name] = tsk
+      name, deps, block = *parse_task_dependencies(name, &block)
+      task_manager.define_task(name, *deps, &block)
     end
 
-    # Define a file target.
-
-    def file(name, &block)
-      tasks[name.to_s] = FileTask.register(name, &block)
+    # Run a task.
+    def run(name)
+      task_manager.call(name)
     end
 
+    private
+
+      #
+      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
   end
 
+  # = TaskManager Class
   #
-  #
-  #
-
-  class Task
+  class TaskManager
+    attr :main
+    attr :tasks
 
-    def self.tasks
-      @@tasks ||= {}
+    def initialize
+      @main = nil
+      @tasks = {}
     end
 
-    def self.register(name_deps, &block)
-      if Hash===name_deps
-        name = name_deps.keys[0]
-        deps = name_deps.values[0]
-      else
-        name = name_deps
-        deps = []
-      end
-      tasks[name.to_s] = new(name, *deps, &block)
+    def define_main(name=nil, *depend, &block)
+      @main = Task.new(name, *depend, &block)
+      tasks[@main.name] = @main
     end
 
-    attr :name
-    attr :preqs
-    attr :action
-
-    #
-
-    def initialize(name, *preqs, &action)
-      @name          = name.to_s
-      @preqs         = preqs
-      @action        = action
+    def define_task(name, *depend, &block)
+      task = Task.new(name, *depend, &block)
+      tasks[task.name] = task
     end
 
-    def call
-  #p plan
-      plan.each{ |name| @@tasks[name].action_call }
-      #action_call
+    def call_main
+      return unless @main
+      call(@main.name)
     end
 
-    #
-
-    def action_call
-      @action.call if @action
+    # Call task.
+    def call(name)
+      plan(name).each{ |name| @tasks[name].call }
+      #action_call
     end
 
-    # TODO Check for circular dependencies.
-
-    def plan(list=[])
+    # Prepare plan, checking for circular dependencies.
+    def plan(name, list=[])
       if list.include?(name)
         raise "Circular dependency #{name}."
       end
-
-      @preqs.each do |need|
+      task = @tasks[name]
+      task.preqs.each do |need|
         need = need.to_s
         next if list.include?(need)
-        @@tasks[need].plan(list)
+        @tasks[need].plan(need, list)
       end
-      list << name
+      list << task.name
       return list
     end
 
   end
 
+  # = Task class
   #
-  #
-  #
+  class Task
+
+    attr :name
+    attr :preqs
+    attr :action
+
+    #
+    def initialize(name, *preqs, &action)
+      @name          = name.to_s
+      @preqs         = preqs
+      @action        = action
+    end
+
+    #
+    def call
+      @action.call if @action
+    end
 
-  class FileTask < Task
   end
 
-end
+end #module Ratch