reap 6.0.2 → 9.2.0

data/lib/reap/manager/log.rb

@@ -0,0 +1,214 @@
+require 'reap/manager/scm'
+
+module Reap
+
+  class Manager
+
+    # Update all logs.
+
+    def log(*args)
+      log_changes(*args)
+      log_notes(*args)
+    end
+
+    # Generate ChangeLog. This routes to the
+    # source control manager library.
+
+    def log_changes(options=nil)
+      options = configure_options(options, 'log-changes', 'log')
+      scm_log(options)
+    end
+
+    # TODO: Add ability to read header notes.
+
+    # Collect embedded notes.
+    #
+    # This task scans source code for developer notes and writes to
+    # well organized files. This tool can lookup and list TODO, FIXME
+    # and other types of labeled comments from source code.
+    #
+    #   files    Glob(s) of files to search.
+    #   labels   Labels to search for. Defaults to [ 'TODO', 'FIXME' ].
+    #   output   Output directory. Defaults to log/.
+    #
+    # TODO: Remove format field, and ultimately use XML as primary format?
+
+    def log_notes(options={})
+      options = configure_options(options, 'log-notes', 'log')
+
+      loadpath = options['loadpath'] || metadata.loadpath
+      labels   = options['labels']   || ['TODO', 'FIXME', 'OPTIMIZE']
+      output   = options['output']   || 'log'
+
+      labels = labels.split(',') if String === labels
+      labels = [labels].flatten.compact
+
+      output.chomp!('/')
+
+      records, counts = log_notes_extract(labels, loadpath)
+      notes = log_notes_format(labels, records, (format=nil))
+
+      if records.empty?
+        puts "No #{labels.join(', ')} notes."
+      else
+        log_notes_save(output, notes, labels)
+        puts counts.collect{|l,n| "#{n} #{l}s"}.join(', ')
+        puts "Notes saved in #{output} folder."
+      end
+    end
+
+    private
+
+    # Gather notes.
+
+    def log_notes_extract(labels, loadpath=nil)
+      files = Dir.multiglob_r(*loadpath)
+
+      counts = Hash.new(0)
+      records = []
+
+      files.each do |fname|
+        next unless fname =~ /.*rb/      # TODO should this be done?
+        File.open(fname) do |f|
+          line_no, save, text = 0, nil, nil
+          while line = f.gets
+            line_no += 1
+            labels.each do |label|
+              if line =~ /^\s*#\s*#{Regexp.escape(label)}[:]?\s*(.*?)$/
+                file = fname
+                text = ''
+                save = {'label'=>label,'file'=>file,'line'=>line_no,'note'=>text}
+                records << save
+                counts[label] += 1
+              end
+            end
+            if text
+              if line =~ /^\s*[#]{0,1}\s*$/ or line !~ /^\s*#/ or line =~ /^\s*#[+][+]/
+                text.strip!
+                text = nil
+                #records << save
+              else
+                text << line.gsub(/^\s*#\s*/,'')
+              end
+            end
+          end
+        end
+      end
+      return records, counts
+    end
+
+    # Format notes.
+
+    def log_notes_format(labels, records, format=nil)
+      #return "No #{labels.join('/')} notes." if records.empty?
+      #return {} if records.empty?
+      notes = {}
+      labels.each do |label|
+        recs = records.select{ |r| r['label'] == label }
+        next if recs.empty?
+        out = "\n= #{label}\n"
+        last_file = nil
+        recs.sort!{ |a,b| a['file'] <=> b['file'] }
+        recs.each do |record|
+          if last_file != record['file']
+            out << "\n"
+            last_file = record['file']
+            out << "file://#{record['file']}\n"
+          end
+          out << "* #{record['note'].rstrip} (#{record['line']})\n"
+        end
+        notes[label] = out
+      end
+      return notes
+    end
+
+    # Save notes.
+
+    def log_notes_save(dir, notes, labels)
+      mkdir_p(dir)
+      # Remove empty note files.
+      (labels - notes.keys).each do |label|
+        file = File.join(dir,label)
+        rm(file) if File.file?(file)
+      end
+      # Create note files.
+      notes.each do |label, note|
+        file = apply_naming_policy(label, 'txt')
+        file = File.join(dir,file)
+        if dryrun?
+          puts "write #{file}"
+        else
+          File.open(file,'w') do |f| f << note end
+        end
+      end
+    end
+
+    #
+
+    def naming_policy
+      @naming_policy ||= (
+        logconfig = configuration['log'] || {}
+        logconfig['policy'] || DEFAULT['log']['policy']
+      )
+    end
+
+    # TODO: Naming policy needs to be apply to changelog too.
+
+    def apply_naming_policy(name, ext)
+      policy = naming_policy
+      name = name.downcase    if /low/i =~ policy
+      name = name.upcase      if /up/i  =~ policy
+      name = name.capitalize  if /cap/i =~ policy
+      name = name + ".#{ext}" if /ext/i =~ policy
+      name
+    end
+
+  end
+
+end
+
+  #     out = ''
+  #
+  #     case format
+  #     when 'yaml'
+  #       out << records.to_yaml
+  #     when 'list'
+  #       records.each do |record|
+  #         out << "* #{record['note']}\n"
+  #       end
+  #     else #when 'rdoc'
+  #       labels.each do |label|
+  #         recs = records.select{ |r| r['label'] == label }
+  #         next if recs.empty?
+  #         out << "\n= #{label}\n"
+  #         last_file = nil
+  #         recs.sort!{ |a,b| a['file'] <=> b['file'] }
+  #         recs.each do |record|
+  #           if last_file != record['file']
+  #             out << "\n"
+  #             last_file = record['file']
+  #             out << "file://#{record['file']}\n"
+  #           end
+  #           out << "* #{record['note'].rstrip} (#{record['line']})\n"
+  #         end
+  #       end
+  #       out << "\n---\n"
+  #       out << counts.collect{|l,n| "#{n} #{l}s"}.join(' ')
+  #       out << "\n"
+  #     end
+
+  #     # List TODO notes. Same as notes --label=TODO.
+  #
+  #     def todo( options={} )
+  #       options = options.to_openhash
+  #       options.label = 'TODO'
+  #       notes(options)
+  #     end
+  #
+  #     # List FIXME notes.  Same as notes --label=FIXME.
+  #
+  #     def fixme( options={} )
+  #       options = options.to_openhash
+  #       options.label = 'FIXME'
+  #       notes(options)
+  #     end

data/lib/reap/manager/make.rb

@@ -0,0 +1,109 @@
+#
+# The Make tool routes to extension Makefile(s).
+# At this point it's designed to support extconf.rb design.
+#
+# TODO: Perhaps make a true compiler class in the future.
+# TODO: win32 cross-compile.
+
+module Reap
+
+  class Manager
+
+    def extensions
+      @extensions ||= metadata.extensions || 'ext/**/extconf.rb'
+    end
+
+    # Return list of extconf.rb scripts.
+
+    def extension_scripts
+      [extensions].flatten.collect do |ext|
+        Dir.glob(ext)
+      end.flatten
+    end
+
+    # Return list of directory locations of extconf.rb scripts.
+
+    def extension_directories
+      glob(extension_scripts).map do |ext|
+        File.dirname(ext)
+      end
+    end
+
+    # Check to see if this project has extensions that need to be compiled.
+
+    def compiles?
+      !extension_directories.empty?
+    end
+
+    # Compile extensions.
+
+    def make
+      make_extconf
+      make_target
+    end
+
+    # Compile static.
+
+    def make_static
+      make_extconf
+      make_target 'static'
+    end
+
+    # Remove enouhg compile products for a clean compile.
+
+    def make_clean
+      make_target 'clean'
+    end
+
+    # Remove all compile products.
+
+    def make_distclean
+      make_target 'distclean'
+    end
+
+    # Create Makefile(s).
+
+    def make_extconf
+      extensions.each do |file|
+        directory = File.dirname(file)
+        next if File.exist?(File.join(directory, 'Makefile'))
+        cd(directory) do
+          sh "ruby #{File.basename(file)}"
+        end
+      end  
+    end
+
+    private
+
+    def make_target(target='')
+      extension_directories.each do |directory|
+        cd(directory) do
+          sh "make #{target}"
+        end
+      end  
+    end
+
+
+    # Eric Hodel said NOT to copy the compiled libs.
+    #
+    #task :copy_files do
+    #  cp "ext/**/*.#{dlext}", "lib/**/#{arch}/"
+    #end
+    #
+    #def dlext
+    #  Config::CONFIG['DLEXT']
+    #end
+    #
+    #def arch
+    #  Config::CONFIG['arch']
+    #end
+
+    # Cross-compile for Windows. (TODO)
+
+    #def make_mingw
+    #  abort "NOT YET IMPLEMENTED"
+    #end
+
+  end
+
+end

data/lib/reap/manager/pack.rb

@@ -0,0 +1,232 @@
+require 'reap/manager/gem'
+
+module Reap
+
+  class Manager
+
+    # Remove packages.
+
+    def clobber_packages(options=nil)
+      options = configure_options(options, 'package')
+
+      store = 'pkg'
+
+      packages = glob(File.join(store, '*'))
+
+      packages.each do |path|
+        rm_r(path)
+        puts "Removed #{path}" unless dryrun?
+      end
+    end
+
+    # General pack command.
+
+    def package(options=nil)
+      packopts = configure_options(options, 'package')
+
+      formats = packopts['formats'] || ['zip']
+      formats = [formats].flatten
+
+      puts
+      formats.each do |format|
+        send("package_#{format}", options)
+        puts
+      end
+    end
+
+    # Routes to $gem_package.
+
+    def package_gem(options=nil)
+      gem_package(options)
+    end
+
+    # Create a Tar'd Gzip package.
+
+    def package_tgz(options=nil)
+      status "Creating .tgz package"
+
+      options = configure_options(options, 'package-tgz', 'package')
+
+      package = metadata.clone
+      package.update(options)
+
+      abort "No name" unless package.name
+      abort "No version" unless package.version
+
+      store = 'pkg' #package.package_directory
+      fname = package.stage_name
+      files = package.filelist
+
+      stage = File.join(store, fname)
+      pfile = stage + ".tgz"
+
+      unless out_of_date?(pfile, *files) or force?
+        report_package_already_built(pfile)
+        return
+      end
+
+      rm_r(stage) if File.exist?(stage)  # remove old stage
+      stage(stage, files)                # make new stage
+      package_manifest(stage)            # generate stage manifest
+
+      if dryrun?
+        status "tar -cxf #{fname}.tgz"
+      else
+        file = nil
+        cd(store) do
+          file = tgz(fname)  # FIXME: Prefer .tgz as extensions.
+        end
+        transfer(file, store)
+        report_package_built(file)
+      end
+    end
+
+    # Create Zip package.
+
+    def package_zip(options=nil)
+      status "Creating .zip package"
+
+      options = configure_options(options, 'package-zip', 'package')
+
+      package = metadata.clone
+      package.update(options)
+
+      abort "No name" unless package.name
+      abort "No version" unless package.version
+
+      store = 'pkg' #package.package_directory
+      fname = package.stage_name
+      files = package.filelist
+
+      stage = File.join(store, fname)
+      pfile = stage + ".zip"
+
+      unless out_of_date?(pfile, *files) or force?
+        report_package_already_built(pfile)
+        return
+      end 
+
+      rm_r(stage) if File.exist?(stage)  # remove old stage
+      stage(stage, files)                # make new stage
+      package_manifest(stage)            # generate manifest
+
+      if dryrun?
+        status "zip -r #{fname}.zip ."
+      else
+        file = nil
+        cd(store) do
+          file = zip(fname)
+        end
+        transfer(file, store)
+        report_package_built(file)
+      end
+    end
+
+    # Create off-line documentation package.
+    #
+    # FIXME: package_docs is not yet ready for use.
+
+    def package_docs(options=nil)
+      options = configure_options(options, 'package-doc')
+
+      dir  = options['dir']     || 'doc'
+      name = options['name']    || metadata.name
+      ver  = options['version'] || metadata.version
+
+      cd(dir) do
+        zip "-czhvf #{name}-docs-#{ver}.zip *"
+      end
+    end
+
+    private
+
+    # Transfer package file to storage location.
+
+    def transfer(file, store)
+      # move to store, unless already there
+      dest = File.join(store, File.basename(file))
+      dest = File.expand_path(dest)
+      mv(file, store) unless file == dest
+    end
+
+    # Generate manifest.
+
+    def package_manifest(dir)
+      return if dryrun?
+      Dir.chdir(dir) do
+        files = Dir['**/*']
+        rm('MANIFEST') if File.exist?('MANIFEST')
+        File.open('MANIFEST', 'w') do |f|
+          f << files.join("\n")
+        end
+      end
+    end
+
+    # Report that a package has been built.
+    # FIXME: will type, name and version always be right?
+
+    def report_package_built(file)
+      file = File.basename(file)
+      type = File.extname(file)
+      name = file[0...file.rindex('-')]
+      vers = file[file.rindex('-')+1..-1].chomp(type)
+
+      puts "  Successfully built #{type}"
+      puts "  Name: #{name}"
+      puts "  Version: #{vers}"
+      puts "  File: #{file}"
+    end
+
+    # Report that a package has been built.
+    # FIXME: will type, name and version always be right?
+
+    def report_package_already_built(file)
+      file = File.basename(file)
+      type = File.extname(file)
+      name = file[0...file.rindex('-')]
+      vers = file[file.rindex('-')+1..-1].chomp(type)
+
+      puts "  Package #{file} is already current."
+      #puts "  Name: #{name}"
+      #puts "  Version: #{vers}"
+      #puts "  File: #{file}"
+    end
+
+  end
+end
+
+  #     # Build packages.
+  #     # TODO Move this to Manager ?
+  #
+  #     def generate_packages
+  #       package_files = formats.collect do |format|
+  #         #format = clean_type(format)
+  #         say '' if format == 'gem'  # FIXME This is here b/c Gems outputs on it's own.
+  #         file = create_package(format)
+  #         unless dryrun? or (format == 'gem')
+  #           report_package_built(format, file) if file
+  #         end
+  #         file
+  #       end
+  #       report_packaging_complete(package_files.size)
+  #     end
+  #
+  #     # Create package.
+  #
+  #     def create_package(type)
+  #       package.format = type
+  #
+  #       builder_class = FormatBuilder.registry[type]
+  #       builder = builder_class.new(package, stage_directory, options)
+  #       file    = builder.build
+  #
+  #       transfer(file) unless dryrun?
+  #
+  #       return file
+  #     end
+  #
+  #     # Report that packaging is complete.
+  #
+  #     def report_packaging_complete(size)
+  #       say "\nSuccessfully built #{size} packages at #{store}/."
+  #     end

data/lib/reap/manager/publish.rb

@@ -0,0 +1,72 @@
+module Reap
+
+  class Manager
+
+    # Publish website to rubyforge.
+    #
+    # This task publishes the source dir (deafult 'doc')
+    # to a rubyforge website.
+    #
+    # Uses RSync to upload files to webserver.
+    #
+    # TODO: Add FTP/SFTP support.
+
+    def publish(options=nil)
+      options = configure_options(options, 'publish', 'rubyforge')
+
+      project  = options['project'] || metadata.project
+      webdir   = options['webdir']
+      source   = options['source']
+      username = options['username']
+      clear    = options['clear']
+      protect  = options['protect']
+      exclude  = options['exclude']
+
+      source   ||= "doc"
+      username ||= ENV['RUBYFORGE_USERNAME']
+
+      if clear
+        protect   = protect().to_a
+        exclude   = exclude().to_a
+      else
+        protect   = %w{usage statcvs statsvn robot.txt wiki} + [protect].flatten
+        exclude   = %w{.svn} + [exclude].flatten
+      end
+
+      abort "No project name." unless project
+      abort "No username." unless username
+
+      if webdir and webdir != '.'
+        destination = File.join(project, webdir)
+      else
+        destination = project
+      end
+
+      dir = source.chomp('/') + '/'
+      url = "#{username}@rubyforge.org:/var/www/gforge-projects/#{destination}"
+
+      op = ['-rLvz', '--delete-after']  # maybe -p ?
+
+      # Using commandline filter options didn't seem
+      # to work, so I opted for creating an .rsync_filter file for
+      # all cases.
+
+      unless protect.empty? && exclude.empty?
+        rsync_file = File.join(source,'.rsync-filter')
+        unless file?(rsync_file)
+          File.open(rsync_file, 'w') do |f|
+            exclude.each{|e| f << "- #{e}\n"}
+            protect.each{|e| f << "P #{e}\n"}
+          end
+        end
+        op << "--filter='dir-merge #{rsync_file}'"
+      end
+
+      args = op + [dir, url]
+
+      sh "rsync #{args.to_params}"
+    end
+
+  end
+
+end