ratch 0.4.1 → 1.0.0

data/lib/ratch/index.rb

@@ -0,0 +1,4 @@
+module Ratch
+  VERSION = "1.0.0"
+end
+

data/lib/ratch/io.rb

@@ -0,0 +1,116 @@
+require 'facets/consoleutils'
+
+module Ratch
+
+  # = Ratch IO
+  #
+  # The IO class is used to cleanly separate out the
+  # basic input/output "dialog" between user and script.
+  #
+  class IO
+
+    #
+    attr :runmode
+
+    #
+    def initialize(runmode)
+      @runmode = runmode
+    end
+
+    def force?  ; runmode.force?  ; end
+    def quiet?  ; runmode.quiet?  ; end
+    def trace?  ; runmode.trace?  ; end
+    def debug?  ; runmode.debug?  ; end
+    def dryrun? ; runmode.dryrun? ; end
+    def noharm? ; runmode.noharm? ; end
+
+    # Internal status report.
+    #
+    # Only output if dryrun or trace mode.
+    #
+    def status(message)
+      if runmode.dryrun? or runmode.trace?
+        puts message
+      end
+    end
+
+    # Convenient method to get simple console reply.
+    #
+    def ask(question, answers=nil)
+      print "#{question}"
+      print " [#{answers}] " if answers
+      until inp = $stdin.gets ; sleep 1 ; end
+      inp.strip
+    end
+
+    # Ask for a password. (FIXME: only for unix so far)
+    #
+    def password(prompt=nil)
+      msg ||= "Enter Password: "
+      inp = ''
+      print "#{prompt} "
+      begin
+        #system "stty -echo"
+        #inp = gets.chomp
+        until inp = $stdin.gets
+          sleep 1
+        end
+      ensure
+        #system "stty echo"
+      end
+      return inp.chomp
+    end
+
+    def print(str)
+      super(str) unless quiet?
+    end
+
+    def puts(str)
+      super(str) unless quiet?
+    end
+
+    #
+    #
+    def printline(left, right='', options={})
+      return if runmode.quiet?
+
+      separator = options[:seperator] || options[:sep] || ' '
+      padding   = options[:padding]   || options[:pad] || 0
+
+      left, right = left.to_s, right.to_s
+
+      left_size  = left.size
+      right_size = right.size
+
+      left  = colorize(left)
+      right = colorize(right)
+
+      l = padding
+      r = -(right_size + padding + 1)
+
+      line = separator * screen_width
+      line[l, left_size]  = left  if left_size != 0
+      line[r, right_size] = right if right_size != 0
+
+      puts line
+    end
+
+    #
+    def colorize(text)
+      return text unless text.color
+      if PLATFORM =~ /win/
+        text.to_s
+      else
+        ANSICode.send(text.color){ text.to_s }
+      end
+    end
+
+    #
+    def screen_width
+      ConsoleUtils.screen_width
+    end
+
+  end
+
+end
+

data/lib/ratch/pathglob.rb

@@ -0,0 +1,73 @@
+# NOT USED. Expiremental.
+
+require 'pathname'
+
+=begin
+class Pathname
+
+  def glob(*options)
+    opts = 0
+    options.each do |option|
+      case option
+      when :nocase
+        opts += File::FNM_CASEFOLD
+      else
+        opts += option
+      end
+    end
+
+    self.class.glob(to_s, opts).collect{ |f| Pathname.new(f) }
+  end
+
+end
+=end
+
+# How does this differ from facets/filelist?
+
+class PathGlob  #:nodoc:
+
+  #
+  attr :patterns
+  attr :options
+
+  def <<(pattern)
+    patterns << pattern
+  end
+
+  #
+  def match?(path)
+    patterns.find{ |pattern| File.fnmatch?(pattern, path) }
+  end
+
+  #
+  def match(*options)
+    opts = 0
+    options.each do
+      case options
+      when :nocase
+        opts += File::FNM_CASEFOLD
+      end
+    end
+    patterns.collect{ |pattern| File.glob(pattern, opts) }.flatten
+  end
+
+  def file?(*options)
+    match(options).all?{ |f| File.file?(f) }
+  end
+
+  def directory?(*options)
+    match(options).all?{ |f| File.directory?(f) }
+  end
+
+private
+
+  def initialize(*patterns)
+    @patterns = patterns
+  end
+
+  def self.[](*patterns)
+    new(*patterns)
+  end
+
+end
+

data/lib/ratch/plugin.rb

@@ -0,0 +1,55 @@
+module Ratch
+
+  # = PLugin
+  #
+  # A Plugin is essentially a delegated Service class..
+  #
+  # The plugin acts a base class for ecapsulating batch routines.
+  # This helps to keep the main batch context free of the clutter
+  # of private supporting methods.
+  #
+  # Plugins are tightly coupled to the batch context,
+  # which allows them to call on the context easily.
+  # However this means plugins cannot be used independent
+  # of a batch context, and changes in the batch context
+  # can cause effects in plujgin behvior that can be harder
+  # to track down and fix if a bug arises.
+  #
+  # Unless the tight coupling of a plugin is required, use the
+  # loose coupling of a Service class instead.
+
+  class Plugin
+
+    # The batch context.
+    attr :context
+
+    alias_method :project, :context
+
+    private
+
+    #
+    def initialize(context, options=nil)
+      @context = context
+
+      raise TypeError, "context must be a subclass of Ratch::DSL" unless context.is_a?(Ratch::DSL)
+
+      initialize_defaults
+
+      options ||= {}
+      options.each do |k, v|
+        send("#{k}=", v) if respond_to?("#{k}=")
+      end
+    end
+
+    def initialize_defaults
+    end
+
+    # TODO: This should be optional? How?
+    def method_missing(s, *a, &b)
+      @context.send(s, *a, &b)
+    end
+
+  end
+
+end
+

data/lib/ratch/runmode.rb

@@ -0,0 +1,69 @@
+module Ratch
+
+  # = Runmode
+  #
+  # The Runmode class encapsulates common options for command line scripts.
+  # The built-in modes are:
+  #
+  #   force
+  #   trace
+  #   debug
+  #   dryrun -or- noharm
+  #   silent -or- quiet
+  #   verbose
+  # 
+  class Runmode
+
+    def self.load_argv!
+      options = {
+        :force   => %w{--force}.any?{ |x| ARGV.delete(x) },
+        :trace   => %w{--trace}.any?{ |x| ARGV.delete(x) },
+        :debug   => %w{--debug}.any?{ |x| ARGV.delete(x) },
+        :dryrun  => %w{--noharm --dryrun --dry-run}.any?{ |x| ARGV.delete(x) },
+        :silent  => %w{--silent --quiet}.any?{ |x| ARGV.delete(x) },
+        :verbose => %w{--verbose}.any?{ |x| ARGV.delete(x) }
+      }
+      new(options)
+    end
+
+    def initialize(options={})
+      options.rekey(&:to_sym)
+
+      @force   = options[:force]
+      @trace   = options[:trace]
+      @debug   = options[:debug]
+      @noharm  = options[:noharm] || options[:dryrun]
+      @silent  = options[:silent] || options[:quiet]
+      @verbose = options[:verbose]
+    end
+
+    attr_accessor :force
+
+    attr_accessor :trace
+
+    attr_accessor :verbose
+
+    attr_accessor :silent
+
+    attr_accessor :debug
+
+    attr_accessor :noharm
+
+    alias_method :dryrun, :noharm
+    alias_method :dryrun=,:noharm
+
+    alias_method :quiet,  :silent
+    alias_method :quiet=, :silent=
+
+    def force?   ; @force   ; end
+    def trace?   ; @trace   ; end
+    def debug?   ; @debug   ; end
+    def noharm?  ; @noharm  ; end
+    def dryrun?  ; @noharm  ; end
+    def quiet?   ; @silent  ; end
+    def verbose? ; @verbose ; end
+
+  end
+
+end
+

data/lib/ratch/script.rb

@@ -0,0 +1,52 @@
+require 'ratch/dsl'
+#require 'annotatable'
+
+module Ratch
+
+  # = Ratch Script
+  #
+  # The Ratch Script class is used to run stand-alone ratch scripts.
+  # Yep, this is actaully a class named exactly for what it is.
+  # How rare.
+  #
+  class Script < DSL
+    #include Annotatable
+
+    #
+    #annotation :cmd
+
+    #
+    #annotation :opt
+
+    #
+    #def commands
+    #  c = {}
+    #  self.class.annotations.each do |n, a|
+    #    if a.key?(:cmd)
+    #      c[n] = a[:cmd]
+    #    end
+    #  end
+    #  c
+    #end
+
+    #
+    #def initialize   
+    #  @noharm  = %w{-n --noharm --dryrun --dry-run}.any?{ |a| ARGV.delete(a) }
+    #  @verbose = %w{--verbose}.any?{|a| ARGV.delete(a) }
+    #  @quiet   = %w{--quiet}.any?{|a| ARGV.delete(a) }
+    #  @force   = %w{--force}.any?{|a| ARGV.delete(a) }
+    #  @debug   = %w{--debug}.any?{|a| ARGV.delete(a) }
+    #  @trace   = %w{--trace}.any?{|a| ARGV.delete(a) }
+    #
+    #  super
+    #end
+
+    #  @noharm  ||= %w{noharm n dryrun dry-run}.any?{|a| commandline.options[a] }
+    #  @verbose ||= %w{verbose}.any?{|a| commandline.options[a] }
+    #  @force  ||= %w{force}.any?{|a| commandline.options[a] }
+    #  @debug ||= %w{debug}.any?{|a| commandline.options[a] }
+    #  @trace ||= %w{trace}.any?{|a| commandline.options[a] }
+
+  end
+
+end

data/lib/ratch/service.rb

@@ -0,0 +1,33 @@
+require 'ratch/dsl'
+
+module Ratch
+
+  # = Service
+  #
+  # In particular this means creating module for RunModes and FileUtils
+  # which uses it, as these are the primary couplings between the batch
+  # context and the services that are shared by all.
+
+  class Service < DSL
+
+    private
+
+    #
+    def initialize(options=nil)
+      options ||= {}
+
+      initialize_defaults
+
+      options.each do |k, v|
+        send("#{k}=", v) if respond_to?("#{k}=")
+      end
+    end
+
+    #
+    def initialize_defaults
+    end
+
+  end
+
+end
+

data/lib/ratch/task.rb

@@ -0,0 +1,249 @@
+
+  module Taskable
+
+    def self.included(base)
+      base.extend(Dsl)
+    end
+
+    # Run a task. Better name?
+    def run(target)
+      #t = self.class.tasks(target)
+      #t.run(self)
+      send("#{target}:target")
+    end
+
+    module Dsl
+      # 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 < Taskable}
+          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}:target"){ task.run(self) }  # or use #run?
+        define_method("#{target}:task", &function) # TODO: in 1.9 use instance_exec instead.
+      end
+    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 < Taskable}.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
+
+