ratch 0.2.3 → 0.3.0

data/lib/ratch/{argvutils.rb → batch/argvutils.rb}

@@ -31,28 +31,35 @@ module Ratch
   module ArgvUtils
 
     def commandline
-      @commandline ||= (ARGV.dup).extend(Ext)
+      @commandline ||= ArgVector.new(ARGV)
     end
     alias_method :argument_vector, :commandline
 
-    module Ext
+    #
+
+    class ArgVector
+      attr :argv
+
+      def initialize(argv)
+        @argv = argv.dup
+      end
 
       def arguments
-        @arguments ||= select{ |e| e !~ /^-/ && e !~ /=/ }
+        @arguments ||= argv.select{ |e| e !~ /^-/ && e !~ /=/ }
       end
 
       def options
         @options ||= (
           pms = {}
-          select{ |e| e =~ /=/ }.each do |e|
-            pms.store(*split('='))
+          argv.select{ |e| /[=]/ =~ e }.each do |e|
+            pms.store(*e.split('='))
           end
           pms
         )
       end
 
       def flags
-        @flags ||= select{ |e| e =~ /^-/ || e !~ /=/ }
+        @flags ||= argv.select{ |e| e =~ /^-/ || e !~ /=/ }
       end
 
       # Have specific flag?
@@ -61,6 +68,16 @@ module Ratch
         flags.include?(flag)
       end
 
+      #
+      def [](x)
+        case x
+        when Integer
+          arguments[x]
+        else
+          options[x.to_s]
+        end
+      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
@@ -71,29 +88,20 @@ module Ratch
       #   argv.value('--say')  #=> "hello"
       #   argv.arguments  #=> ["tom", "hello"]
       #
+
       def value(flag)
-        fetch(index(flag)+1)
+        argv.fetch(index(flag)+1)
       end
 
       #
       def value!(flag)
         @values ||= {}
         @values[flag] ||= (
-          delete(index(flag))
-          delete(index(flag))
+          argv.delete(index(flag))
+          argv.delete(index(flag))
         )
       end
 
-#       #
-#       def [](x)
-#         case x
-#         when Integer
-#           super(x)
-#         else
-#           value(x.to_s)
-#         end
-#       end
-
     end
   end
 end

data/lib/ratch/batch/build.rb

@@ -0,0 +1,95 @@
+# TITLE:
+#
+#   Build
+#
+# 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
+
+  # = Build class
+
+  class Build
+
+    attr :match
+    attr :needs
+    attr :action
+
+    alias_method :name, :match
+
+    # Create a new build definition.
+
+    def initialize(match, *needs, &action)
+      @match         = match
+      @needs         = needs
+      @action        = action
+    end
+
+    # Call this build process for the given path.
+
+    def call(path)
+      if needs.empty?
+        dated = true
+      elsif File.exist?(path)
+        mtime = File.mtime(path)
+        dated = needs.find do |file|
+          !File.exist?(file) || File.mtime(file) > mtime
+        end
+      else
+        dated = true
+      end
+      action.call(path) if dated
+    end
+
+    # Does a file match this build definition?
+
+    def match?(path)
+      case match
+      when String
+        File.fnmatch(match, path)
+      when Regexp
+        match =~ path
+      else
+        false        # ???
+      end
+    end
+
+    # Is this build needed to update/create path?
+
+    def needed_for?(path)
+      return true unless File.exist?(path)
+      return true if needed_paths.empty?  # TODO: if there are no prereqs then the file is always considered needed. Correct?
+      mtimes = needed_paths.collect do |f|
+        File.exist?(f) ? File.mtime(f) : Time.now
+      end
+      mtimes.max > File.mtime(path)
+    end
+
+    # Glob expanded needs.
+
+    def needed_paths
+      #exact = needs.select{|n| File.fnmatch?(n,n)} +
+      exact = needs.select{|n| n !~ /[\[*?]/ }
+      globs = needs.collect{|n| Dir.glob(n)}.flatten
+      (exact + globs).uniq
+    end
+
+  end
+
+end

data/lib/ratch/{fileutils.rb → batch/fileutils.rb}

@@ -22,8 +22,8 @@
 #   along with Ratch.  If not, see <http://www.gnu.org/licenses/>.
 
 require 'fileutils'
-require 'ratch/facets/multiglob'
-
+require 'facets/dir/multiglob'
+require 'ratch/support/filetest'
 
 module Ratch
 
@@ -170,36 +170,36 @@ module Ratch
 #       task if FileTest.file?(task) && FileTest.executable?(task)
 #     end
 
-    # Is a file a command executable?
-    #
-    # TODO Probably needs to be fixed for Windows.
-
-    def bin?(path)
-      is_bin = command_paths.any? do |f|
-        FileTest.exist?(File.join(f, path))
-      end
-      is_bin ? File.basename(path) : false
-    end
-
-    # This is a support method of #bin?
-
-    def command_paths
-      @command_paths ||= ENV['PATH'].split(/[:;]/)
-    end
-
-    # TODO Make more robust.
-
-    UNSAFE = [ '/', '/*', '/**/*' ]
-
-    # Is a path considered reasonably "safe"?
-
-    def safe?(path)
-      case path
-      when *UNSAFE
-        return false
-      end
-      true
-    end
+#     # Is a file a command executable?
+#     #
+#     # TODO Probably needs to be fixed for Windows.
+#
+#     def bin?(path)
+#       is_bin = command_paths.any? do |f|
+#         FileTest.exist?(File.join(f, path))
+#       end
+#       is_bin ? File.basename(path) : false
+#     end
+#
+#     # This is a support method of #bin?
+#
+#     def command_paths
+#       @command_paths ||= ENV['PATH'].split(/[:;]/)
+#     end
+#
+#     # TODO Make more robust.
+#
+#     UNSAFE = [ '/', '/*', '/**/*' ]
+#
+#     # Is a path considered reasonably "safe"?
+#
+#     def safe?(path)
+#       case path
+#       when *UNSAFE
+#         return false
+#       end
+#       true
+#     end
 
   end
 end

data/lib/ratch/batch/task.rb

@@ -0,0 +1,43 @@
+# TITLE:
+#
+#   Task
+#
+# 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
+
+  # Task is a very simple store for the defined
+  # actions and it's 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

data/lib/ratch/manager.rb

@@ -0,0 +1,34 @@
+
+module Ratch
+
+   class Manager
+
+     def toolset_directory
+       File.join(File.dirname(__FILE__), 'toolset')
+     end
+
+     #
+
+     def toolset
+       files = []
+       Dir.chdir(toolset_directory) do
+         files = Dir.glob('**/*')
+       end
+       files
+     end
+
+     #
+
+     def tool?(fname)
+       file = File.join(toolset_directory, fname)
+       if File.exist?(file)
+         file
+       else
+         false
+       end
+     end
+
+   end
+
+end
+

data/lib/ratch/project/information.rb

@@ -0,0 +1,257 @@
+# = TITLE:
+#
+#   Information
+#
+# = 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 'facets/hash/rekey'
+
+
+module Ratch
+
+  # Validation Error
+  class ValidationError < Exception
+  end
+
+  #
+
+  class Information
+
+    class << self
+
+      def instance_attributes
+        @attributes ||= []
+      end
+
+      # Define an attribute.
+
+      def attr_accessor(name, *aliases, &blk)
+        instance_attributes << name.to_s
+        instance_attributes.uniq!
+        if blk
+          define_method(name, &blk)
+          attr_writer(name)
+        else
+          super(name)
+        end
+        aliases.each{ |aliaz| alias_accessor(aliaz, name) }
+      end
+
+      # Define an attribute alias.
+
+      def alias_accessor(aliaz, name)
+        alias_method aliaz, name
+        alias_method "#{aliaz}=", "#{name}="
+      end
+
+      def validation
+        @validation ||= []
+      end
+
+      def validate(message, &block)
+        validation << [message, block]
+      end
+
+      # Does this class provide open access?
+      #
+      #def open_access?
+      #  false
+      #end
+
+    end
+
+
+    def instance_data
+      @instance_data ||= {}
+    end
+
+    # List attributes. (Needed?)
+
+    def attributes
+      self.class.instance_attributes
+    end
+
+
+    # Initialize
+    ####################
+
+    def initialize(data={})
+      update(data)
+    end
+
+    def update(data)
+      instance_data.update(data.rekey(:to_s))
+
+      data.each do |k,v|
+        send("#{k}=", v) rescue nil
+      end
+
+      # TODO Could add yield(self) via:
+      #yld.to_h.each do |k,v|
+      #  send( "#{k}=", v ) rescue nil
+      #end
+    end
+
+
+    # Access
+    ####################
+
+    # Fetch attribute value, but return nil if it doesn't exist.
+    #--
+    # TODO Use in method missing instead?
+    #++
+
+    def [](name)
+      begin
+        h = send(name)
+      rescue NoMethodError
+        h = nil
+      end
+    end
+
+    # Gathers a group of info hash entries into a merged hash.
+    # The +names+ are taken in most to least significant order.
+    #
+    #   gather(:package)
+    #
+    # TODO Change name of this method to something better?
+
+    def gather( *names )
+      result = names.inject({}) do |hash,name|
+        attributes.each do |n|
+          if n.to_s =~ /^#{name}_(.*?)$/
+            hash[$1] = self[n.to_s] if self[n.to_s]
+          end
+        end
+        hash
+      end
+      result
+    end
+
+    # Collects a group of info entries into a hash.
+    # Arguments are a list of info entry names and/or
+    # a hash or new name to info entry name.
+    #
+    #   select(:name, :version, :date => :released)
+    #
+    # This is used to collect info to pass to tools.
+
+    def select( *args )
+      maps = (Hash === args.last ? args.pop : {})
+      h = {}
+      args.each{ |k|    h[k.to_s] = self[k] }
+      maps.each{ |k, i| h[k.to_s] = self[i] }
+      h
+    end
+
+
+    # Validation
+    ######################
+
+    #
+    def valid?
+      begin
+        validate
+        return true
+      rescue ValidationError
+        return false
+      end
+    end
+
+    #
+    def validate
+      self.class.validation.each do |message, block|
+        raise(ValidationError, message) unless instance_eval(&block)
+      end
+    end
+
+    alias_method :assert_valid, :validate
+
+
+    # Conversion
+    #################
+
+    # Order of attributes for yaml conversion.
+
+    def to_yaml_properties
+      attributes.collect{ |a| "@#{a}" }
+    end
+
+    # Use YAML format.
+
+    def to_yaml( opts={} )
+      require 'yaml'
+      super
+    end
+
+    # For yaml conversion, no tag.
+
+    def taguri; nil; end
+
+    # Convert to hash.
+
+    def to_hash
+      attributes.inject({}) do |h, a|
+        v = self[a.to_s] #send(a)
+        h[a] = v unless v.nil?
+        h
+      end
+    end
+    alias_method :to_h, :to_hash
+
+    # Use generic XML format.
+
+    def to_xml( opts={} )
+      raise "not yet implemented"
+    end
+
+#     # Use XOXO microformat.
+#
+#     def to_xoxo( opts={} )
+#       begin
+#         require 'blow/xoxo'  # EXTERNAL DEPENDENCY!
+#       rescue LoadError
+#         puts 'Blow (http://blow.rubyforge.org) is required to use XOXO format'
+#       end
+#       XOXO.dump(self.to_hash, opts)
+#     end
+
+
+    # Arbitrary information
+    ############################
+
+#     # TODO Perhaps not define this at all if open_access? is false.
+#
+#     def method_missing( s, *a, &b )
+#       super unless self.class.open_access?
+#       s = s.to_s
+#       if s[-1,1] == '='
+#         (class << self; self; end).class_eval do
+#           attr_accessor s.chomp('=')
+#         end
+#         send(s,*a,&b)
+#       else
+#         nil #super
+#       end
+#     end
+
+  end
+
+end