reap 6.0.2 → 9.2.0

data/lib/reap/manager/announce.rb

@@ -0,0 +1,193 @@
+module Reap
+
+  class Manager
+
+    # Make a release announcement. Generates and can email release
+    # announcements. The announcement if built from the README file
+    # unless another file is specified.
+    #
+    # This will subsititue the first line mathing /please see notes/i
+    # for the notelog. And /please see change/i for the changelog.
+    #
+    # The following settings apply:
+    #
+    #     title        Project title.
+    #     subtitle     Brief one-line description.
+    #     version      Project version.
+    #     description  Long description of project.
+    #     homepage     Project homepage web address.
+    #     slogan       Motto for you project.
+    #     memo         File that contains announcement message.
+    #     template     Announcement template file, rather then README.
+    #     mail_to      Email address(es) to send announcemnt.
+    #
+    # If <em>mail_to</em> is set then these also apply:
+    #
+    #     from         Message FROM address [email].
+    #     subject      Subject of email message ([ANN] title verison).
+    #     server       Email server to route message.
+    #     port         Email server's port.
+    #     domain       Email server's domain name.
+    #     account      Email account name [email].
+    #     login        Login type: plain, cram_md5 or login.
+    #     secure       Uses TLS security, true or false?
+    #
+    # A template file can be specified that uses "$setting" as
+    # substitutes for poject information.
+
+    def announce(options=nil)
+      options = configure_options(options, 'announce', 'mail')
+
+      message = announce_message(options)
+
+      options = options.to_ostruct
+
+      mail_to     = options.mail_to
+      mail_from   = options.mail_from
+      subject     = options.subject         # Subject line (default is "ANN: project version").
+      server      = options.server          # Email server
+      port        = options.port            # Emails server port (default is usually correct).
+      account     = options.account         # Email account name (defaults to mail_from).
+      domain      = options.domain          # User domain (not sure why SMTP requires this?)
+      login       = options.login           # Login type (plain, login)
+      secure      = options.secure          # Use TLS/SSL true or false?
+      password    = options.password || ENV['EMAIL_PASSWORD']
+
+      title       = options.title       || metadata.title
+      version     = options.versoin     || metadata.version
+
+      # defaults
+      subject ||= "ANN: #{title}, v#{version}"
+      account ||= mail_from
+
+      subject = subject % [title, version]
+
+      puts "\n#{message}\n\n"
+
+      if mail_to and !dryrun?
+        ans = ask("Would you like to email this announcement?", "yN")
+        case ans.downcase
+        when 'y', 'yes'
+          email(message,
+            :to       => mail_to,
+            :from     => mail_from,
+            :subject  => subject,
+            :server   => server,
+            :port     => port,
+            :domain   => domain,
+            :account  => account,
+            :login    => login,
+            :secure   => secure,
+            :password => password
+          )
+        end
+      end
+    end
+
+    # Make a release announcement. Generates and can email a release
+    # announcements. These are nicely formated message and can
+    # email the message to the specified address(es).
+    #
+    # The following settings apply:
+    #
+    #     template     Announcement file/template.
+    #     cutoff       Max number of lines of changelog to show.
+    #
+    # A template file can be specified that uses "$setting" as
+    # substitutes for poject information.
+
+    def announce_message(options={})
+      config  = settings['announce'] || {}
+      options = config.merge(options).to_ostruct
+
+      cutoff   = options.cutoff    || 30
+      template = options.template  || "{ANNOUNCE,README}{,.txt}"
+
+      #config['mail_to'] = nil if keys['mail_to'].empty?
+
+      # Build message
+
+      # template
+      template = Dir.glob(options.template.to_s, File::FNM_CASEFOLD).first
+      abort "No announcememnt template." unless template
+
+      #
+      readme = File.read(template)
+      readme = unfold_paragraphs(readme)
+
+      # changelog
+      file   = Dir.glob('change{s,log}{,.txt}', File::FNM_CASEFOLD)[0]
+      changelog = file ? File.read(file).strip : ''
+      #changelog = unfold_paragraphs(changelog)
+      changelog = changelog.split("\n")[0..cutoff].join("\n")
+
+      # noteslog
+      file = Dir.glob('note{s,log}{,.txt}', File::FNM_CASEFOLD)[0]
+      notelog  = file ? File.read(file).strip : ''
+      notelog  = unfold_paragraphs(notelog)
+
+      # Strip tiny version zero.
+      #if keys['version'] =~ /[.].*?[.]/
+      #  keys['version'] = keys['version'].chomp('.0')
+      #end
+
+      # Make announcement message
+      message = readme.dup
+
+      #message.gsub!('$readme$', readme || '')
+      message.sub!(/^\s*please\ see(\ the)?\ notes(.*?)$/i, "\n" + notelog) if notelog
+      message.sub!(/^\s*please\ see(\ the)?\ change(.*?)$/i, "\n" + changelog) if changelog
+
+      template = message.dup
+
+      template.scan(/[$](.*?)[$]/m) do |key|
+        #key   = key.strip
+        name  = $1.strip #key[1..-1]
+        if metadata.respond_to?(name.downcase)
+          value = metadata.send(name.downcase)
+          message.gsub!("$#{name}$", value.to_s.strip)
+        else
+          puts "Warning: Unknown project field -- #{name}."
+        end
+      end
+
+      message.gsub!(/(^|[ ])[$].*?(?=[ ]|$)/,'') # remove unused vars
+      message.gsub!(/\n\s*\n\s*\n/m,"\n\n")       # remove any triple blank lines
+      message.rstrip!
+
+      return message
+    end
+
+    def unfold_paragraphs(string)
+      blank = false
+      text  = ''
+      string.split(/\n/).each do |line|
+        if /\S/ !~ line
+          text << "\n\n"
+          blank = true
+        else
+          if /^(\s+|[*])/ =~ line 
+            text << (line.rstrip + "\n")
+          else
+            text << (line.rstrip + " ")
+          end
+          blank = false
+        end
+      end
+      return text
+    end
+
+  end
+
+end
+
+  #       keys = {}
+  #       keys['from'] = info.email
+  #       keys.update info.gather('mail')
+  #       keys.update info.gather('announce')
+  #       keys.update info.select(
+  #         :project, :version, :title, :subtitle, :description,
+  #         :homepage, :download, :slogan
+  #       )
+  #       keys.update override if override
+

data/lib/reap/manager/check.rb

@@ -0,0 +1,109 @@
+module Reap
+
+  class Manager
+
+    # Verify syntax of ruby scripts.
+    #
+    # This takes one option +:scripts+ which is a glob or list of globs
+    # of the scripts to check. By default this is all scripts in the libpath(s).
+
+    def check_syntax(options=nil)
+      options = configure_options(options, 'check-syntax', 'check')
+
+      libpath = options['loadpath'] || metadata.loadpath
+      exclude = options['exclude']
+
+      #libpath = libpath.split(/[:;]/) unless Array===libpath
+      libpath = list_option(libpath)
+      exclude = list_option(exclude)
+
+      files   = multiglob_r(*libpath) - multiglob_r(exclude)
+      files   = files.select{ |f| File.extname(f) == '.rb' }
+      max     = files.collect{ |f| f.size }.max
+      list    = []
+
+      files.each do |s|
+        next unless File.file?(s)
+        #if not system "ruby -c -Ibin:lib:test #{s} &> /dev/null" then
+        r = system "ruby -c -I#{libpath} #{s} > /dev/null 2>&1"
+        if r
+          puts("%-#{max}s  [PASS]" % [s]) #if verbose?
+        else
+          puts("%-#{max}s  [FAIL]" % [s]) #if verbose?
+          list << s #:syntax
+        end
+      end
+
+      puts "  #{list.size} Syntax Errors"
+
+      if verbose?
+        unless list.empty?
+          puts "\n-- Syntax Errors --\n"
+          list.each do |f|
+            print "* "
+            system "ruby -c -I#{libpath} #{f} 2>&1"
+            #puts
+          end
+          puts
+        end
+      end
+    end
+
+    # Load each script independently to ensure there are no
+    # require dependency issues.
+    #
+    # WARNING! You should only run this on scripts that have no
+    # toplevel side-effects!!!
+    #
+    # This takes one option +:scripts+ which is a glob or list of globs
+    # of the scripts to check. By default this is all scripts in the libpath(s).
+    #
+    # FIXME: This isn't routing output to dev/null as expected.
+
+    def check_load(options=nil)
+      options = configure_options(options, 'check-load', 'check')
+
+      make if compiles?
+
+      libpath = options['libpath'] || metadata.libpath
+      exclude = options['exclude']
+
+      libpath = list_option(libpath)
+      exclude = list_option(exclude)
+
+      files = multiglob_r(*libpath) - multiglob_r(exclude)
+      files   = files.select{ |f| File.extname(f) == '.rb' }
+      max   = files.collect{ |f| f.size }.max
+      list  = []
+
+      files.each do |s|
+        next unless File.file?(s)
+        #if not system "ruby -c -Ibin:lib:test #{s} &> /dev/null" then
+        cmd = "ruby -I#{libpath.join(':')} #{s} > /dev/null 2>&1"
+        puts cmd if debug?
+        if r = system(cmd)
+          puts "%-#{max}s  [PASS]" % [s]
+        else
+          puts "%-#{max}s  [FAIL]" % [s]
+          list << s #:load
+        end
+      end
+
+      puts "  #{list.size} Load Failures"
+
+      if verbose?
+        unless list.empty?
+          puts "\n-- Load Failures --\n"
+          list.each do |f|
+            print "* "
+            system "ruby -I#{libpath} #{f} 2>&1"
+            #puts
+          end
+          puts
+        end
+      end
+    end
+
+  end
+
+end

data/lib/reap/manager/clean.rb

@@ -0,0 +1,58 @@
+module Reap
+
+  class Manager
+
+    # Clean scrap products. All directory paths and or file globs
+    # listed under the clean configuration entry, can be removed via
+    # this method. By default all files ending with "~" or .back
+    # are removed. To specifcy an alternate provide a list of files
+    # and/or glibs under +remove:+ sub-entry. You can also provide
+    # an +exclude:+ sub-entry to isolate files not to be removed.
+    # For example, on might do:
+    #
+    #   clean:
+    #     remove [ '**/*~', '**/*.bak', '.config' ]
+    #
+    # Clean is run as a prerequiste to #release via #prepare.
+
+    def clean(options=nil)
+      options = configure_options(options, 'clean')
+
+      remove  = options['remove']
+      exclude = options['exclude']
+
+      remove  = list_option(remove)
+      exclude = list_option(exclude)
+
+      files   = multiglob_r(*remove) - multiglob_r(exclude)
+
+      return if files.empty?
+
+      puts files.join("\n")
+
+      if verbose?
+        ans = ask("Remove files?", "yN").downcase
+        return unless ans == 'y' or ans == 'yes'
+      end
+
+      files.each do |f|
+        rm(f) if File.exist?(f)
+      end
+    end
+
+    # Run all clobber methods. This method literally looks for all other
+    # methods starting with the phrase "clobber_" and calls them, then
+    # runs #clean as well.
+
+    def clobber(options=nil)
+      clobber_methods = methods.select{ |m| m.to_s =~ /^clobber_/ }
+      clobber_methods.each do |m|
+        send(m)
+      end
+      clean
+    end
+
+  end
+
+end
+

data/lib/reap/manager/gem.rb

@@ -0,0 +1,200 @@
+module Reap
+
+  class Manager
+
+    # Remove gem package products.
+
+    def gem_clobber(options=nil)
+      store = "pkg"
+
+      packages = glob(File.join(store, '*.gem'))
+
+      packages.each do |path|
+        File.directory?(path) ? rm_r(path) : rm(path)
+      end
+    end
+
+    # Create a Gem package.
+    #
+    # TODO: Should this use staging too, like zip/tgz?
+
+    def gem_package(options=nil)
+      begin
+        require 'rubygems/specification'
+        Gem::manage_gems
+      rescue LoadError
+        #raise LoadError, "RubyGems is not installed?"
+      end
+
+      status "Creating .gem package"
+
+      options = configure_options(options, 'package-gem', '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 + ".gem"
+
+      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 "gem build #{stage}"
+      else
+        file = nil
+        cd(stage) do
+          #status "vi #{metadata.name}.gemspec"
+          builder = ::Gem::Builder.new(gemspec(package))
+          status "gem build #{stage}"
+          unless dryrun?
+            file = builder.build
+            file = File.expand_path(file)
+          end
+        end
+        # transfer gem package to package store
+        mkdir_p(store)
+        destination = File.join(store, File.basename(file))
+        mv(file, store) unless File.expand_path(file) == File.expand_path(destination)
+      end
+
+      return destination
+    end
+
+    # Install gem package, creating the package if not already created.
+    #
+    # TODO: Endure that we even need a gem package using #out_of_date?
+
+    def gem_install(options=nil)
+      file = gem_package(options)
+      sh "gem install #{file}"
+    end
+
+    # Uninstall gem package.
+    #
+    # TODO: Sepcify version?
+
+    def gem_uninstall
+      i = metadata.package_name.rindex('-')
+      name, version = metadata.package_name[0...i], metadata.package_name[i+1..-1]
+      sh "gem uninstall #{name} -v #{version}"
+    end
+
+    private
+
+    # Create Gem::Specification.
+
+    def gemspec(package)
+      distribute = package.filelist
+      #distribute = Dir.multiglob_with_default( '**/*', distribute )
+
+      # I don't quite get how Rubygems deals with authors. It turns a singel value into an array. Why?
+      #author = [package.author, package.contact].flatten.compact.first
+
+      if md = /(\w+).rubyforge.org/.match(package.homepage)
+        rubyforge_project = md[1]
+      else
+        rubyforge_project = package.project  # b/c it has to be something according to Eric Hodel.
+      end
+
+      ::Gem::Specification.new do |spec|
+        spec.name              = package.package
+        spec.version           = package.version
+        spec.summary           = package.brief
+        spec.description       = package.description
+        spec.author            = package.contact
+        spec.email             = package.email
+        spec.rubyforge_project = rubyforge_project
+        spec.homepage          = package.homepage
+
+        # Platform: ruby, mswin32, i586-linux, powerpc-darwin, current
+        spec.platform = 'ruby'  # TODO current support!
+
+        spec.require_paths = [package.gem_path].flatten.reverse
+
+        #if package.platform != 'ruby'
+        #  spec.require_paths.concat(spec.require_paths.collect{ |d| File.join(d, platform) })
+        #end
+
+        spec.bindir = "bin"
+        spec.executables  = package.executables
+        spec.requirements = package.requirements
+        spec.has_rdoc     = !(FalseClass===package.document)
+
+        if package.dependencies
+          package.dependencies.each do |d,v|
+            spec.add_dependency(*[d,v].compact)
+          end
+        end
+
+        spec.extensions = package.compile
+
+        spec.files = distribute
+
+        spec.test_files = distribute.select{ |f| f =~ /^test\// }  # TODO make test_files configurable
+      end
+    end
+
+    # Report that a package has been built.
+    # FIXME
+
+    def report_package_built(type, file)
+      r = ''
+      r << "\n  Successfully built #{type}"
+      r << "\n  Name: #{package.name}"
+      r << "\n  Version: #{package.version}"
+      r << "\n  File: #{File.basename(file)}"
+      say r
+    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/html.rb

@@ -0,0 +1,69 @@
+module Reap
+
+  class Manager
+
+    # Create web index.html from README. (Not yet used)
+
+    def html
+      require 'rdoc/markup/simple_markup'
+      require 'rdoc/markup/simple_markup/to_html'
+
+      options = configure_options(options, 'html')
+
+      output = options['output']
+      files  = options['files']
+      style  = options['css']
+
+      output ||= 'doc'
+      files  ||= '[A-Z]*'
+      style  ||= Dir.glob('*.css').first
+
+      files = Dir.glob(files)
+
+      s = SM::SimpleMarkup.new
+      h = SM::ToHtml.new
+
+      files.each do |file|
+        unless File.exist?(file)
+          puts "Warning: file does not exist -- #{file}"
+        end
+      end
+
+      mkdir_p(output) unless dryrun?
+
+      files.each do |file|
+        name = file.downcase.chomp('.txt')
+        if /^readme/ =~ name
+          name = "index"
+        end
+        path = File.join(output, name + '.html')
+
+        if dryrun?
+          puts "[DRYRUN] Create #{path}"
+        else
+          next unless out_of_date?(path, file)
+
+          title = "#{package.title} #{name.upcase}"
+
+          input  = File.read(file)
+          output = s.convert(input, h)
+
+          File.open(path, 'w') do |f|
+            f << %{<html>}
+            f << %{<head>}
+            f << %{  <title>#{title}<title>}
+            f << %{  <link rel="stylesheet" TYPE="text/css" HREF="#{style}">} if style
+            f << %{</head>}
+            f << %{<body>}
+            f << output
+            f << %{</body>}
+            f << %{</html>}
+          end
+          puts "Created #{path}"
+        end
+      end
+    end
+
+  end
+
+end