rhype 0.1.0

data/MANIFEST

@@ -0,0 +1,25 @@
+bin
+lib
+meta
+README
+HISTORY
+VERSION
+NEWS
+COPYING
+bin/rhype
+lib/rhype
+lib/rhype/command.rb
+lib/rhype/host.rb
+lib/rhype/command.help
+lib/rhype/controller.rb
+lib/rhype/service.rb
+lib/rhype/metadata.rb
+lib/rhype/index.rb
+lib/rhype/hosts
+lib/rhype/hosts/rubyforge.rb
+lib/rhype/hosts/gforge.rb
+meta/homepage
+meta/unixname
+meta/author
+meta/description
+meta/contact

data/NEWS

@@ -0,0 +1,22 @@
+I didn't really wnat to create this project. Honest.
+But there were a couple of things I didn't like about
+the rubyforge gem: it dummped config info into ones
+home directory (without using the XDG standard) and
+it couldn't automatically login.
+
+Besides that I figure I could probably make the tool
+a little more flexible and support additional hosts
+as needed.
+
+So that's how RHype was born. Originally this code
+has been dwelling as a support library in the Reap
+project. Hey, now it's free to live it's own life :)
+
+Acknowlegement go to Ara T. Howard who wrote the 
+original rubyfoorge.rb script on which this code is
+largely based.
+
+### 0.1.0 / 2008-11-24
+
+  * Initial Release.
+

data/README

@@ -0,0 +1,13 @@
+= RHype
+
+RHype is a commandline interface for interacting with online project hosts.
+
+== Install
+
+  gem install rhype
+
+== Copyright
+
+RHype (c) 2008 TigerOps
+Distributed under the terms of the GPLv3.
+

data/VERSION

@@ -0,0 +1 @@
+rhype 0.1.0 beta (2008-11-23)

data/bin/rhype

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'rhype/command'
+
+RHype::Command.start
+

data/lib/rhype/command.help

@@ -0,0 +1,29 @@
+Usage: hype <action>[:host] [options]
+
+Actions can very from host to host, but hosts generally
+offer one or more of the following services:
+
+  publish       Publish website
+  release       Release package
+  announce      Announce release
+  touch         Check host availability
+
+Specifying a host name limits the action to that specific host.
+If no host name is given, then each host that responds to the
+given action will be invoked in turn. A confirmation prompt will
+appear for each host unless --force is used.
+
+Action and host options can be given on the command line using
+opt=arg notation. To facilitate easy reuse, however, place options
+in the hype configuration file. 
+
+The following options are for the commandline only and are common
+to all commands.
+
+  -n --dryrun      Only pretend to do action
+  -d --debug       Output detailed error reports
+  -f --force       Automatically answer 'y' to queires
+  -h --help        Display help information
+
+See API documentation to learn the options for each action and host.
+

data/lib/rhype/command.rb

@@ -0,0 +1,82 @@
+require 'facets/argvector'
+require 'rhype/controller'
+
+module RHype
+
+  # = Command
+  #
+  # Provides CLI interface to RHype Controller.
+  class Command
+
+    HELPFILE = File.join(File.dirname(__FILE__), 'command.help')
+
+    attr :hostname
+
+    attr :action
+
+    attr :arguments
+
+    attr :options
+
+    #
+    def initialize
+      argv = Argvector.new
+
+      args, opts = *argv.parameters
+      cmd = args.shift
+
+      opts.each do |key, val|
+        case key
+        when 'help', 'h'
+          puts File.read(HELPFILE)
+          exit 0
+        when 'dryrun'
+          $DRYRUN = true
+        when 'quiet'
+          $QUIET = true
+        when 'force'
+          $FORCE = true
+        when 'trace'
+          $TRACE = true
+        when 'debug'
+          $DEBUG = true
+        end      
+      end
+
+      unless cmd
+        puts "No command given."
+        exit -1
+      end
+
+      action, hostname = *cmd.split(':')
+
+      @hostname  = hostname
+      @action    = action
+      @arguments = args
+      @options   = opts
+    end
+
+    #
+    def call
+      begin
+        app = Controller.new(hostname, options)
+        app.call(action) #arguments)
+      rescue => e
+        if $TRACE || $DEBUG
+          raise e
+        else
+          puts e.to_s
+        end
+      end
+    end
+
+    # class methods ------------------------------------------------
+
+    def self.start
+      new.call
+    end
+   
+  end
+
+end
+

data/lib/rhype/controller.rb

@@ -0,0 +1,71 @@
+require 'rhype/hosts/gforge'
+require 'rhype/hosts/rubyforge'
+#require 'rhype/hosts/email'
+
+module RHype
+
+  class Controller
+
+    CONFIG_FILE = '.config/rhype/config.yaml'
+
+    attr :hosts
+
+    attr :config
+
+    attr :options
+
+    # New RHype Controller.
+    def initialize(hostname, options)
+      @options = options.rekey(&:to_s)
+
+      load_configuration
+
+      if hostname
+        @hosts = [hostname.to_s.downcase]
+      else
+        @hosts = config.keys
+      end
+
+      @host_cache = {}
+    end
+
+    # Load configuration.
+    def load_configuration
+      file = Dir.glob(CONFIG_FILE, File::FNM_CASEFOLD).first
+      if file
+        @config = YAML::load(File.new(file))
+      else
+        #raise "#{CONFIG_FILE} not found"
+        @config = {}
+        RHype.register.each do |key, klass|
+          @config[key] = {'type' => key}
+        end
+      end
+    end
+
+    # Invoke action.
+    def call(action) #, arguments)
+      raise "No hosts." if hosts.empty?
+      # loop thru hosts and invoke action.
+      hosts.each do |name|
+        opts = config[name] || {}
+        type = opts.delete('type')
+        opts = opts.merge(options)
+        host(name, type, opts).__send__(action, options)
+      end
+    end
+
+    #
+    def host(name, type, options)
+      name  = name.to_sym
+      @host_cache[name] ||= (
+        klass = Host[type]
+        raise "Undefined host name: #{name}" unless klass
+        klass.new(options)
+      )
+    end
+
+  end
+
+end
+

data/lib/rhype/host.rb

@@ -0,0 +1,55 @@
+require 'rhype/service'
+
+module RHype
+
+  def self.register
+    @register ||= {}
+  end
+
+  # = Host
+  #
+  # Base class for Host Services.
+  #
+  class Host < Service
+
+    def self.[](name)
+      RHype.register[name.to_s.downcase]
+    end
+
+    def self.inherited(base)
+      name = base.to_s.split('::').last.downcase
+      RHype.register[name] = base
+    end
+
+    # Generic announce confirmation.
+# "Release to #{self.class.basename.downcase}?"
+    def confirm?(message, options={})
+      return true if force?
+      ans = ask(message, "yN")
+      case ans.downcase
+      when 'y', 'yes'
+        true
+      else
+        false
+      end
+    end
+
+    DEFAULT_ANNOUNCEMENT = "doc/ann{,ounce}{.txt,.rdoc}"
+
+      #ans = ask("Announce to #{self.class.basename.downcase}?", "yN")
+
+    #
+
+    def announcement(file=nil)
+      template = file || DEFAULT_ANNOUNCEMENT
+      project.generate('templates'=>template)
+      file = Dir.glob(template, File::FNM_CASEFOLD).first
+      text = File.read(file)
+      text = unfold_paragraphs(text)
+      text
+    end
+
+  end
+
+end
+

data/lib/rhype/hosts/gforge.rb

@@ -0,0 +1,755 @@
+# TODO: remove these two dependencies
+#require 'facets' #/hash/rekey'
+require 'facets/kernel/ask'
+
+require 'ostruct'
+require 'httpclient'
+
+require 'rhype/host'
+
+module RHype
+
+  # = GForge
+  #
+  # Interface with the GForge based hosting services.
+  # Supports the following tasks:
+  #
+  # * release  - Upload release packages
+  # * publish  - Publish website
+  # * announce - Post news announcement
+  # * touch    - Test connection
+  #
+  class GForge < Host
+
+    #HOME    = ENV["HOME"] || ENV["HOMEPATH"] || File.expand_path("~")
+    COOKIEJAR  = File::join(Dir.tmpdir, 'reap', 'cookie.dat')
+    REPORT     = /<h\d><span style="color:red">(.*?)<\/span><\/h\d>/
+
+    # Project unixname.
+    attr_accessor :unixname
+
+    # Project name.
+    attr_accessor :version
+
+    # Project's group id number.
+    attr_accessor :group_id
+
+    alias_method :group, :group_id
+
+    # Username for project account.
+    attr_accessor :username
+
+    # Password for project account.
+    attr_accessor :password
+
+    #
+    attr_accessor :domain
+
+    private
+
+      def initialize(options) #, spec, mode)
+        #@unixname = unixname
+
+        options.each do |k,v|
+          send("#{k}=", v) if respond_to?("#{k}=")
+        end
+
+        raise "missing unixname in #{self.class.name}" unless @unixname
+        raise "missing domain in #{self.class.name}" unless @domain
+
+        @package_ids = {}
+        @release_ids = {}
+        @file_ids    = {}
+
+        FileUtils.mkdir_p(File.dirname(COOKIEJAR))
+      end
+
+      #def initialize_defaults
+      #  @unixname = metadata.unixname
+      #  @version  = metadata.version
+      #end
+
+    public
+
+    # URI = http:// + domain name
+    #
+    # TODO: Deal with https, and possible other protocols too.
+
+    def uri
+      @uri ||= URI.parse("http://" + domain)
+    end
+
+    #
+
+    def cookie_jar
+      COOKIEJAR
+    end
+
+    public
+
+    # Website location on server.
+    def siteroot
+      "/var/www/gforge-projects"
+    end
+
+    # What commands does this host support.
+
+    def commands
+      %w{ touch release publish post }
+    end
+
+
+    # Login to website.
+
+    def login # :yield:
+      load_project_cached
+
+      page = @uri + "/account/login.php"
+      page.scheme = 'https'
+      page = URI.parse(page.to_s) # set SSL port correctly
+
+      form = {
+        "return_to"      => "",
+        "form_loginname" => username,
+        "form_pw"        => password,
+        "login"          => "Login with SSL"
+      }
+      html = http_post(page, form)
+
+      if not html[/Personal Page/]
+        puts "Login failed."
+        re1 = Regexp.escape(%{<h2 style="color:red">})
+        re2 = Regexp.escape(%{</h2>})
+        html[/#{re1}(.*?)#{re2}/]
+        raise $1
+      else
+        @printed_project_name ||= (puts "Project: #{unixname}"; true)
+      end
+
+      if block_given?
+        begin
+          yield
+        ensure
+          logout
+        end
+      end
+    end
+
+    # Logout of website.
+
+    def logout
+      page = "/account/logout.php"
+      form = {}
+      http_post(page, form)
+    end
+
+    # Touch base with server -- login and logout.
+
+    def touch(options={})
+      login
+      puts "Group ID: #{group_id}"
+      puts "Login/Logout successful."
+      logout
+    end
+
+    # Upload release packages to hosting service.
+    #
+    # This task releases files to RubyForge --it should work with other
+    # GForge instaces or SourceForge clones too.
+    #
+    # While defaults are nice, you may want a little more control. You can
+    # specify additional attributes:
+    #
+    #     files          package files to release.
+    #     exclude        Package formats to exclude from files.
+    #                    (from those created by pack)
+    #     unixname       Project name on host.
+    #     package        Package to which this release belongs (defaults to project)
+    #     release        Release name (default is version number)
+    #     version        Version of release
+    #     date           Date of release (defaults to Time.now)
+    #     processor      Processor/Architecture (any, i386, PPC, etc.)
+    #     is_public      Public release? (defualts to true)
+    #     changelog      Change log file
+    #     notelog        Release notes file
+    #
+    # The release option can be a template by using %s in the
+    # string. The version number of your project will be sub'd
+    # in for the %s. This saves you from having to update
+    # the release name before every release.
+    #
+    #--
+    # What about releasing a pacman PKGBUILD?
+    #++
+
+    def release(options)
+      options = options.rekey
+
+      version   = options[:version]   || metadata.version
+      changelog = options[:changelog]
+      notelog   = options[:notelog]
+
+      unixname  = options[:unixname]  || unixname()
+      package   = options[:package]   || unixname()
+      release   = options[:release]   || version()
+      name      = options[:name]      || package
+      files     = options[:file]      || []
+      date      = options[:date]      || Time::now.strftime('%Y-%m-%d %H:%M')
+      processor = options[:processor] || 'Any'
+      store     = options[:store]     || 'pkg'
+
+      is_public = options[:is_public].nil? ? true : options[:is_public]
+
+      raise ArgumentError, "missing unixname" unless unixname
+      raise ArgumentError, "missing package"  unless package
+      raise ArgumentError, "missing release"  unless release
+
+      if files.empty?
+        files = Dir[File.join(store, '*')].select do |file|
+          /#{version}[.]/ =~ file
+        end
+        #files = Dir.glob(File.join(store,"#{name}-#{version}*"))
+      end
+
+      files = files.select{ |f| File.file?(f) }
+
+      abort "No package files." if files.empty?
+
+      files.each do |file|
+        abort "Not a file -- #{file}" unless File.exist?(file)
+        puts "Release file: #{file}"
+      end
+
+      # which package types
+      #rtypes = [ 'tgz', 'tbz', 'tar.gz', 'tar.bz2', 'deb', 'gem', 'ebuild', 'zip' ]
+      #rtypes -= exclude
+      #rtypes = rtypes.collect{ |rt| Regexp.escape( rt ) }
+      #re_rtypes = Regexp.new('[.](' << rtypes.join('|') << ')$')
+
+      puts "Releasing #{package} #{release}..." #unless options['quiet']
+
+      login do
+
+        raise ArgumentError, "missing group_id" unless group_id
+
+        unless package_id = package?(package)
+          if dryrun?
+            puts "Package '#{package}' does not exist."
+            puts "Create package #{package}."
+            abort "Cannot continue in dryrun mode."
+          else
+            #unless options['force']
+            q = "Package '#{package}' does not exist. Create?"
+            a = ask(q, 'yN')
+            abort "Task canceled." unless ['y', 'yes', 'okay'].include?(a.downcase)
+            #end
+            puts "Creating package #{package}..."
+            create_package(package, is_public)
+            unless package_id = package?(package)
+              raise "Package creation failed."
+            end
+          end
+        end
+        if release_id = release?(release, package_id)
+          #unless options[:force]
+          if dryrun?
+            puts "Release #{release} already exists."
+          else
+            q = "Release #{release} already exists. Re-release?"
+            a = ask(q, 'yN')
+            abort "Task canceled." unless ['y', 'yes', 'okay'].include?(a.downcase)
+            #puts "Use -f option to force re-release."
+            #return
+          end
+          files.each do |file|
+            fname = File.basename(file)
+            if file_id = file?(fname, package)
+              if dryrun?
+                puts "Remove file #{fname}."
+              else
+                puts "Removing file #{fname}..."
+                remove_file(file_id, release_id, package_id)
+              end
+            end
+            if dryrun?
+              puts "Add file #{fname}."
+            else
+              puts "Adding file #{fname}..."
+              add_file(file, release_id, package_id, processor)
+            end
+          end
+        else
+          if dryrun?
+            puts "Add release #{release}."
+          else
+            puts "Adding release #{release}..."
+            add_release(release, package_id, files,
+              :processor       => processor,
+              :release_date    => date,
+              :release_changes => changelog,
+              :release_notes   => notelog,
+              :preformatted    => '1'
+            )
+            unless release_id = release?(release, package_id)
+              raise "Release creation failed."
+            end
+          end
+          #files.each do |file|
+          #  puts "Added file #{File.basename(file)}."
+          #end
+        end
+      end
+      puts "Release complete!" unless dryrun?
+    end
+
+#     #
+#     # Publish documents to website.
+#     #
+#     # TODO Fix publish method for Rubyforge tool.
+#
+#     def publish(options)
+#       options = options.rekey
+#
+#       #domain = options[:domain] || DOMAIN
+#       root   = File.join(siteroot, unixname)
+#       root   = File.join(root, options[:root]) if options[:root]
+#
+#       options.update(
+#         :host => domain,
+#         :root => root
+#       )
+#
+#       UploadUtils.rsync(options)
+#     end
+
+    # Submit a news item.
+
+    def announce(options)
+      options = options.rekey
+
+      if file = options[:file]
+        text = File.read(file).strip
+        i = text.index("\n")
+        subject = text[0...i].strip
+        message = text[i..-1].strip
+      else
+        subject = options[:subject]
+        message = options[:message] || options[:body]
+      end
+
+      if dryrun?
+        puts "announce-rubyforge: #{subject}"
+      else
+        post_news(subject, message)
+        puts "News item posted!"
+      end
+    end
+
+
+    private
+
+    # HTTP POST transaction.
+
+    def http_post(page, form, extheader={})
+      client = HTTPClient::new ENV["HTTP_PROXY"]
+      client.debug_dev = STDERR if ENV["REAP_DEBUG"] || $DEBUG
+      client.set_cookie_store(cookie_jar)
+      client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      # HACK to fix http-client redirect bug/feature
+      client.redirect_uri_callback = lambda do |uri, res|
+        page = res.header['location'].first
+        page =~ %r/http/ ? page : @uri + page
+      end
+
+      uri = @uri + page
+      if $DEBUG then
+        puts "POST #{uri.inspect}"
+        puts "#{form.inspect}"
+        puts "#{extheader.inspect}" unless extheader.empty?
+        puts
+      end
+
+      response = client.post_content uri, form, extheader
+
+      if response[REPORT]
+        puts "(" + $1 + ")"
+      end
+
+      client.save_cookie_store
+
+      return response
+    end
+
+    #
+
+    def load_project_cached
+      @load_project_cache ||= load_project
+    end
+
+    # Loads information for project: group_id, package_ids and release_ids.
+
+    def load_project
+      html = URI.parse("http://#{domain}/projects/#{unixname}/index.html").read
+
+      group_id = html[/(frs|tracker)\/\?group_id=\d+/][/\d+/].to_i
+      @group_id = group_id
+
+      if $DEBUG
+        puts "GROUP_ID = #{group_id}"
+      end
+
+      html = URI.parse("http://rubyforge.org/frs/?group_id=#{group_id}").read
+
+      package = nil
+      html.scan(/<h3>[^<]+|release_id=\d+">[^>]+|filemodule_id=\d+/).each do |s|
+        case s
+        when /<h3>([^<]+)/ then
+          package = $1.strip
+        when /filemodule_id=(\d+)/ then
+          @package_ids[package] = $1.to_i
+        when /release_id=(\d+)">([^<]+)/ then
+          package_id = @package_ids[package]
+          @release_ids[[package_id,$2]] = $1.to_i
+        end
+      end
+
+      if $DEBUG
+        p @package_ids, @release_ids
+      end
+    end
+
+    # Returns password. If not already set, will ask for it.
+
+    def password
+      @password ||= ENV['RUBYFORGE_PASSWORD']
+      @password ||= (
+        print "Password for #{username}: "
+        until inp = $stdin.gets ; sleep 1 ; end ; puts
+        inp.strip
+      )
+    end
+
+    # Package exists? Returns package-id number.
+
+    def package?(package_name)
+      id = @package_ids[package_name]
+      return id if id
+
+      package_id = nil
+
+      page = "/frs/"
+
+      form = {
+        "group_id" => group_id
+      }
+      scrape = http_post(page, form)
+
+      restr = ''
+      restr << Regexp.escape( package_name )
+      restr << '\s*'
+      restr << Regexp.escape( '<a href="/frs/monitor.php?filemodule_id=' )
+      restr << '(\d+)'
+      restr << Regexp.escape( %{&group_id=#{group_id}} )
+      re = Regexp.new( restr )
+
+      md = re.match( scrape )
+      if md
+        package_id = md[1]
+      end
+
+      @package_ids[package_name] = package_id
+    end
+
+    # Create a new package.
+
+    def create_package( package_name, is_public=true )
+      page = "/frs/admin/index.php"
+
+      form = {
+        "func"         => "add_package",
+        "group_id"     => group_id,
+        "package_name" => package_name,
+        "is_public"    => (is_public ? 1 : 0),
+        "submit"       => "Create This Package"
+      }
+
+      http_post(page, form)
+    end
+
+    # Delete package.
+
+    def delete_package(package_id)
+      page = "/frs/admin/index.php"
+
+      form = {
+        "func"        => "delete_package",
+        "group_id"    => group_id,
+        "package_id"  => package_id,
+        "sure"        => "1",
+        "really_sure" => "1",
+        "submit"      => "Delete",
+      }
+
+      http_post(page, form)
+    end
+
+    # Release exits? Returns release-id number.
+
+    def release?(release_name, package_id)
+      id = @release_ids[[release_name,package_id]]
+      return id if id
+
+      release_id = nil
+
+      page = "/frs/admin/showreleases.php"
+
+      form = {
+        "package_id" => package_id,
+        "group_id"   => group_id
+      }
+      scrape = http_post( page, form )
+
+      restr = ''
+      restr << Regexp.escape( %{"editrelease.php?group_id=#{group_id}} )
+      restr << Regexp.escape( %{&amp;package_id=#{package_id}} )
+      restr << Regexp.escape( %{&amp;release_id=} )
+      restr << '(\d+)'
+      restr << Regexp.escape( %{">#{release_name}} )
+      re = Regexp.new( restr )
+
+      md = re.match( scrape )
+      if md
+        release_id = md[1]
+      end
+
+      @release_ids[[release_name,package_id]] = release_id
+    end
+
+    # Add a new release.
+
+    def add_release(release_name, package_id, *files)
+      page = "/frs/admin/qrs.php"
+
+      options = (Hash===files.last ? files.pop : {}).rekey
+      files = files.flatten
+
+      processor       = options[:processor]
+      release_date    = options[:release_date]
+      release_changes = options[:release_changes]
+      release_notes   = options[:release_notes]
+
+      release_date ||= Time::now.strftime("%Y-%m-%d %H:%M")
+
+      file = files.shift
+      puts "Adding file #{File.basename(file)}..."
+      userfile = open(file, 'rb')
+
+      type_id = userfile.path[%r|\.[^\./]+$|]
+      type_id = FILETYPES[type_id]
+      processor_id = PROCESSORS[processor.downcase]
+
+      # TODO IS THIS WORKING?
+      release_notes   = IO::read(release_notes) if release_notes and test(?f, release_notes)
+      release_changes = IO::read(release_changes) if release_changes and test(?f, release_changes)
+
+      preformatted = '1'
+
+      form = {
+        "group_id"        => group_id,
+        "package_id"      => package_id,
+        "release_name"    => release_name,
+        "release_date"    => release_date,
+        "type_id"         => type_id,
+        "processor_id"    => processor_id,
+        "release_notes"   => release_notes,
+        "release_changes" => release_changes,
+        "preformatted"    => preformatted,
+        "userfile"        => userfile,
+        "submit"          => "Release File"
+      }
+
+      boundary = Array::new(8){ "%2.2d" % rand(42) }.join('__')
+      boundary = "multipart/form-data; boundary=___#{ boundary }___"
+
+      html = http_post(page, form, 'content-type' => boundary)
+
+      release_id = html[/release_id=\d+/][/\d+/].to_i
+      puts "RELEASE ID = #{release_id}" if $DEBUG
+
+      files.each do |file|
+        puts "Adding file #{File.basename(file)}..."
+        add_file(file, release_id, package_id, processor)
+      end
+
+      release_id
+    end
+
+    # File exists?
+    #
+    # NOTE this is a bit fragile. If two releases have the same exact
+    # file name in them there could be a problem --that's probably not
+    # likely, but I can't yet rule it out.
+    #
+    # TODO Remove package argument, it is no longer needed.
+
+    def file?(file, package)
+      id = @file_ids[[file, package]]
+      return id if id
+
+      file_id = nil
+
+      page = "/frs/"
+
+      form = {
+        "group_id"   => group_id
+      }
+      scrape = http_post(page, form)
+
+      restr = ''
+      #restr << Regexp.escape( package )
+      #restr << '\s*'
+      restr << Regexp.escape( '<a href="/frs/download.php/' )
+      restr << '(\d+)'
+      restr << Regexp.escape( %{/#{file}} )
+      re = Regexp.new(restr)
+
+      md = re.match(scrape)
+      if md
+        file_id = md[1]
+      end
+
+      @file_ids[[file, package]] = file_id
+    end
+
+    # Remove file from release.
+
+    def remove_file(file_id, release_id, package_id)
+      page="/frs/admin/editrelease.php"
+
+      form = {
+        "group_id"     => group_id,
+        "package_id"   => package_id,
+        "release_id"   => release_id,
+        "file_id"      => file_id,
+        "step3"        => "Delete File",
+        "im_sure"      => '1',
+        "submit"       => "Delete File "
+      }
+
+      http_post(page, form)
+    end
+
+    #
+    # Add file to release.
+    #
+
+    def add_file(file, release_id, package_id, processor=nil)
+      page = '/frs/admin/editrelease.php'
+
+      userfile = open file, 'rb'
+
+      type_id      = userfile.path[%r|\.[^\./]+$|]
+      type_id      = FILETYPES[type_id]
+      processor_id = PROCESSORS[processor.downcase]
+
+      form = {
+        "step2"        => '1',
+        "group_id"     => group_id,
+        "package_id"   => package_id,
+        "release_id"   => release_id,
+        "userfile"     => userfile,
+        "type_id"      => type_id,
+        "processor_id" => processor_id,
+        "submit"       => "Add This File"
+      }
+
+      boundary = Array::new(8){ "%2.2d" % rand(42) }.join('__')
+      boundary = "multipart/form-data; boundary=___#{ boundary }___"
+
+      http_post(page, form, 'content-type' => boundary)
+    end
+
+    # Posts news item to +group_id+ (can be name) with +subject+ and +body+
+
+    def post_news(subject, body)
+      page = "/news/submit.php"
+
+      subject % [unixname, version]
+
+      form = {
+        "group_id"     => group_id,
+        "post_changes" => "y",
+        "summary"      => subject,
+        "details"      => body,
+        "submit"       => "Submit"
+      }
+
+      login do
+        http_post(page, form)
+      end
+    end
+
+    # Constant for file types accepted by Rubyforge
+
+    FILETYPES = {
+      ".deb"         => 1000,
+      ".rpm"         => 2000,
+      ".zip"         => 3000,
+      ".bz2"         => 3100,
+      ".gz"          => 3110,
+      ".src.zip"     => 5000,
+      ".src.bz2"     => 5010,
+      ".src.tar.bz2" => 5010,
+      ".src.gz"      => 5020,
+      ".src.tar.gz"  => 5020,
+      ".src.rpm"     => 5100,
+      ".src"         => 5900,
+      ".jpg"         => 8000,
+      ".txt"         => 8100,
+      ".text"        => 8100,
+      ".htm"         => 8200,
+      ".html"        => 8200,
+      ".pdf"         => 8300,
+      ".oth"         => 9999,
+      ".ebuild"      => 1300,
+      ".exe"         => 1100,
+      ".dmg"         => 1200,
+      ".tar.gz"      => 3110,
+      ".tgz"         => 3110,
+      ".gem"         => 1400,
+      ".pgp"         => 8150,
+      ".sig"         => 8150
+    }
+
+    # Constant for processor types accepted by Rubyforge
+
+    PROCESSORS = {
+      "i386"       => 1000,
+      "IA64"       => 6000,
+      "Alpha"      => 7000,
+      "Any"        => 8000,
+      "PPC"        => 2000,
+      "MIPS"       => 3000,
+      "Sparc"      => 4000,
+      "UltraSparc" => 5000,
+      "Other"      => 9999,
+
+      "i386"       => 1000,
+      "ia64"       => 6000,
+      "alpha"      => 7000,
+      "any"        => 8000,
+      "ppc"        => 2000,
+      "mips"       => 3000,
+      "sparc"      => 4000,
+      "ultrasparc" => 5000,
+      "other"      => 9999,
+
+      "all"        => 8000,
+      nil          => 8000
+    }
+
+  end
+
+end
+