reap 6.0.2 → 9.2.0

data/data/reap/build/tasks/task/test

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+# Run unit tests
+
+def test
+  live = ARGV.include?('--live')
+
+  unless live
+    $LOAD_PATH.unshift(File.expand_path('lib/core'))
+    $LOAD_PATH.unshift(File.expand_path('lib/more'))
+  end
+
+  puts "Ruby Version: #{RUBY_VERSION}"
+
+  if find = ARGV.select{|e| e !~ /^[-]/ }[0]
+    unless file?(find)
+      find = File.join(find, '**', 'test_*.rb')
+    end
+  else
+    find = 'test/**/test_*.rb'
+  end
+
+  files = Dir.glob(find)
+  files.each do |file|
+    next if File.directory?(file)
+    begin
+      puts "Loading: #{file}" if $DEBUG
+      load(file)
+    rescue LoadError
+      puts "Error loading: #{file}"
+    end
+  end
+end
+
+# Go!
+if $0 == __FILE__
+  test
+end

data/data/reap/init/meta/project.yaml

@@ -0,0 +1,21 @@
+---
+title    : Reap
+summary  : Ruby Project Assistant
+description: >
+  Reap is a Ruby project management system.
+
+project     : reap
+author      : Thomas Sawyer <transfire@gmail.com>
+created     : "2005-08-09"
+homepage    : "http://reap.rubyforge.org"
+repository  : "http://reap.rubyforge.org/svn"
+slogan      : Reap Your Rewards
+
+exclude     : [ pkg, work, doc, ri ]
+
+dependency  :
+  - [facets, ">= 2.1.0"]
+
+loadpath: lib/reap
+
+

data/demo/README

@@ -0,0 +1,15 @@
+= Foo Demo of Reap
+
+This is a demonstration project for playing with reap.
+
+== On Testing
+
+At this point Reap does not have unit tests. Reap is so predominatly
+FileIO as well as configurable that it can be tricky to get strong
+test coverage. So for now at least, I'm using the old fashion method
+of beta testers.
+
+To facilitate this, we have this demo project that can by played with,
+and the trust --dryrun option. Always use the --dryrun option first,
+until one is confident in an reap's action.
+

data/demo/lib/foo/foo.rb

@@ -0,0 +1,7 @@
+
+# Say hello, Gracy.
+
+def hello
+  "Hello, Gracy"
+end
+

data/demo/meta/VERSION

@@ -0,0 +1 @@
+0.0.1 alpha (2008-02-07)

data/demo/meta/project.yaml

@@ -0,0 +1,21 @@
+---
+project  : foo
+
+title    : Foo
+brief    : A Very Fooy Project
+description: >
+  Foo foo went hopping thru the forest.
+
+author      : Thomas Sawyer <transfire@gmail.com>
+created     : "2008-02-09"
+homepage    : "http://orphans.rubyforge.org"
+repository  : "http://orphans.rubyforge.org/svn"
+slogan      : Footastic
+
+exclude     : [ pkg, work, doc, ri ]
+
+dependency  :
+  - [facets, ">= 2.1.0"]
+
+libpath: lib/foo
+

data/lib/reap/application.rb

@@ -0,0 +1,80 @@
+#require 'facets/ansicode'
+
+module Reap
+  require 'reap/project'
+
+  # Application is the commandline interface.
+
+  class Application
+
+    attr_reader :manager
+
+    def initialize
+      #vector  = ArgVector.new
+      #arguments = vector.arguments
+      #options   = vector.options
+
+      opts = {}
+      opts['dryrun']  = options.delete('dryrun')
+      opts['trace']   = options.delete('trace')
+      opts['force']   = options.delete('force')
+      opts['verbose'] = options.delete('verbose')
+      opts['debug']   = options.delete('debug')
+      opts
+
+      @manager = Project.new(opts)
+
+      #@arguments = arguments
+      #@options   = options
+    end
+
+    def argv
+      @argv ||= ARGV.dup
+    end
+
+    def arguments
+      @arguments ||= argv.select{ |e| e !~ /^-/ && e !~ /=/ }
+    end
+
+    def options
+      @options ||= (
+        pms = {}
+        argv.select{ |e| /[=]/ =~ e }.each do |e|
+          k,v = e.split('=')
+          k = k.sub(/^[-]{1,2}/,'')
+          pms.store(k,v)
+        end
+        argv.select{ |e| e =~ /^-/ && e !~ /=/ }.each do |k|
+          k = k.sub(/^[-]{1,2}/,'')
+          pms.store(k,true)
+        end
+        pms
+      )
+    end
+
+    #
+
+    def method_missing(cmd, *args)
+      opts = options.dup
+      opts['arguments'] = arguments unless arguments.empty?
+      args << opts
+      manager.invoke(cmd, *args)
+    end
+
+    #     # TODO: Collect reap bin commands and give short descriptions.
+    #
+    #     def display_commands
+    #       cmds = Application.commands
+    #       #cmds.sort!{ |a,b| a[0] <=> b[0] }
+    #       size = cmds.collect{ |(k,m,v)| k.to_s.size }.max + 2
+    #       cmds.each do |(k,m,v)|
+    #         next unless v
+    #         next if k.index(':') or k.index('-') unless task?
+    #         puts " %-#{size}s # %s" % [k, v]
+    #       end
+    #     end
+    #   end
+
+  end
+
+end

data/lib/reap/default.yaml

@@ -0,0 +1,77 @@
+---
+announce:
+  template: '{ANNOUNCE,README}{,.txt}'                    # Announcement template file glob.
+  mail_to: rubytalk@ruby-lange.org                        # Email address(es) to send announcemnt.
+  mail_from: #{metadata.email}                            # Message FROM address.
+  subject: "ANN: %s %s"                                   # Subject of email message. Sprintf'd against name and version.
+  account: #{metadata.email}                              # Email account name [email].
+  domain: rubyforge.org                                   # Your domain. (Not sure why one needs this for an email.)
+  server: smtp.goolge.com                                 # Email server to route message.
+  port: 25                                                # Email server's port, if not secure.
+  port_secure: 465                                        # Email server's port, if secure.
+  secure: false                                           # Uses TLS security, true or false?
+  login: plain                                            # Login type: plain, cram_md5 or login.
+  cutoff: 30                                              # How many lines of changelog to provide.
+check:
+  loadpath: #{metadata.loadpath}
+  exclude: []
+check-syntax:
+  loadpath: #{metadata.loadpath}
+  exclude: [ext]
+check-load:
+  loadpath: #{metadata.loadpath}
+  exclude: []
+clean:
+  remove: [**/*~, **/*.bak]
+log:
+  policy: [cap, ext]                                      # How to save log files. (cap=capitialize, up=uppercase, low=lowercase, ext=extension)
+  output: log
+log-notes:
+  loadpath: #{metadata.loadpath}                          # Files to search for notes.
+  labels: [TODO, FIXME, OPTIMIZE]
+make:
+  extensions: #{metadata.extensions}                      # Defaults to ext/**/extconf.rb  (NOT USED YET)
+package:
+  formats: [zip, gem]
+publish:
+  source: doc
+  webdir: ~
+  username: #{ENV['RUBYFORGE_USERNAME']}
+  protect: [usage, statcvs, statsvn, robot.txt, wiki]     # Used as defaults for creating .rsync-filter (after that edit .rsync-filter)
+  exclude: [.svn, scrap]                                  # Used as defaults for creating .rsync-filter (after that edit .rsync-filter)
+rdoc:
+  template: html
+  output: doc/rdoc
+  main: 'README{,.txt}'
+  inline: true
+  merge: true
+  exclude: []
+  include: ['lib', '[A-Z]*']
+  adfile: doc/ads/rdoc.html
+  targets: ~
+ri:
+  output: ri
+  exclude: []
+  include: #{metadata.loadpath}
+release:
+  username: #{ENV['RUBYFORGE_USERNAME']}
+  changelog: 'CHANGES{,.txt}'
+  notelog: 'NOTES{,.txt}'
+spec:
+  specs: [spec/**/*_spec.rb, spec/**/spec_*.rb]
+  loadpath: #{metadata.loadpath}
+  require: []
+  warning: false
+  command: spec
+  live: false
+stats:
+  loadpath: #{metadata.loadpath}
+  exclude: ['ext']
+test:
+  tests: test/**/{test,tc}_*.rb
+  loadpath: #{metadata.loadpath}
+  require: []
+  exclude: ext
+  command: testrb
+  live: false
+

data/lib/reap/extensions/array.rb

@@ -0,0 +1,50 @@
+module Reap
+module Extensions
+
+  # Array Extensions
+
+  module Array
+
+    # Not empty?
+
+    def not_empty?
+      !empty?
+    end
+
+    # Convert an array into command line parameters.
+    # The array is accepted in the format of Ruby
+    # method arguments --ie. [arg1, arg2, ..., hash]
+
+    def to_console
+      flags = (Hash===last ? pop : {})
+      flags = flags.to_console
+      flags + ' ' + join(" ")
+    end
+    alias_method :to_params, :to_console
+
+  #   def to_console
+  #     flags = (Hash===last ? pop : {})
+  #     flags = flags.collect do |f,v|
+  #       m = f.to_s.size == 1 ? '-' : '--'
+  #       case v
+  #       when Array
+  #         v.collect{ |e| "#{m}#{f} '#{e}'" }.join(' ')
+  #       when true
+  #         "#{m}#{f}"
+  #       when false, nil
+  #         ''
+  #       else
+  #         "#{m}#{f} '#{v}'"
+  #       end
+  #     end
+  #     return (flags + self).join(" ")
+  #   end
+
+  end
+
+end
+end
+
+class Array #:nodoc:
+  include Reap::Extensions::Array
+end

data/lib/reap/extensions/hash.rb

@@ -0,0 +1,63 @@
+require 'ostruct'
+
+module Reap
+module Extensions
+
+  #
+
+  module Hash
+
+    # Convert an array into command line parameters.
+    # The array is accepted in the format of Ruby
+    # method arguments --ie. [arg1, arg2, ..., hash]
+
+    def to_console
+      flags = collect do |f,v|
+        m = f.to_s.size == 1 ? '-' : '--'
+        case v
+        when Array
+          v.collect{ |e| "#{m}#{f}='#{e}'" }.join(' ')
+        when true
+          "#{m}#{f}"
+        when false, nil
+          ''
+        else
+          "#{m}#{f}='#{v}'"
+        end
+      end
+      flags.join(" ")
+    end
+
+    # Turn a hash into arguments.
+    #
+    #   h = { :list => [1,2], :base => "HI" }
+    #   h.argumentize #=> [ [], { :list => [1,2], :base => "HI" } ]
+    #   h.argumentize(:list) #=> [ [1,2], { :base => "HI" } ]
+    #
+    def argumentize(args_field=nil)
+      config = dup
+      if args_field
+        args = [config.delete(args_field)].flatten.compact
+      else
+        args = []
+      end
+      args << config
+      return args
+    end
+
+    alias_method :command_vector, :argumentize
+
+    #
+
+    def to_ostruct
+      OpenStruct.new(self)
+    end
+
+  end
+
+end
+end
+
+class Hash #:nodoc:
+  include Reap::Extensions::Hash
+end

data/lib/reap/extensions/string.rb

@@ -0,0 +1,31 @@
+module Reap
+module Extensions
+
+  # String Extensions
+
+  module String
+
+    # Find actual filename (casefolding) and returns it.
+    # Returns nil if no file is found.
+
+    def to_actual_filename
+      Dir.glob(self, File::FNM_CASEFOLD).first
+    end
+
+    # Find actual filename (casefolding) and replace string with it.
+    # If file not found, string remains the same and method returns nil.
+
+    def to_actual_filename!
+      filename = to_actual_filename
+      replace(filename) if filename
+    end
+
+  end
+
+end
+end
+
+class String #:nodoc:
+  include Reap::Extensions::String
+end
+

data/lib/reap/extensions.rb

@@ -0,0 +1,6 @@
+require 'facets/dir/multiglob'
+
+require 'reap/extensions/array'
+require 'reap/extensions/hash'
+require 'reap/extensions/string'
+

data/lib/reap/iobject.rb

@@ -0,0 +1,264 @@
+# = 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 'yaml'
+require 'facets/hash/rekey'
+
+
+module Reap
+
+  #
+
+  class InfoObject
+
+    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 alias_method(aliaz, name)
+        super
+        if method_defined?("#{name}=")
+          super("#{aliaz}=", "#{name}=")
+        end
+      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 TypeError
+        return false
+      end
+    end
+
+    #
+    def validate
+      self.class.validation.each do |message, block|
+        raise(TypeError, 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