Ruby on Rails | Screencasts | Download | Documentation | Weblog | Community | Source

Changeset 4204

Show
Ignore:
Timestamp:
04/09/06 22:14:08 (3 years ago)
Author:
david
Message:

Use Aras RubyForge uploader

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/stable/actionmailer/Rakefile

    r4194 r4204  
    8585 
    8686desc "Publish the release files to RubyForge." 
    87 task :release => [:package] do 
    88   files = ["gem", "tgz", "zip"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" } 
     87task :release => [ :package ] do 
     88  `rubyforge login` 
    8989 
    90   if RUBY_FORGE_PROJECT then 
    91     require 'net/http' 
    92     require 'open-uri' 
    93  
    94     project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/" 
    95     project_data = open(project_uri) { |data| data.read } 
    96     group_id = project_data[/[?&]group_id=(\d+)/, 1] 
    97     raise "Couldn't get group id" unless group_id 
    98  
    99     # This echos password to shell which is a bit sucky 
    100     if ENV["RUBY_FORGE_PASSWORD"] 
    101       password = ENV["RUBY_FORGE_PASSWORD"] 
    102     else 
    103       print "#{RUBY_FORGE_USER}@rubyforge.org's password: " 
    104       password = STDIN.gets.chomp 
    105     end 
    106  
    107     login_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    108       data = [ 
    109         "login=1", 
    110         "form_loginname=#{RUBY_FORGE_USER}", 
    111         "form_pw=#{password}" 
    112       ].join("&") 
    113       http.post("/account/login.php", data) 
    114     end 
    115  
    116     cookie = login_response["set-cookie"] 
    117     raise "Login failed" unless cookie 
    118     headers = { "Cookie" => cookie } 
    119  
    120     release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}" 
    121     release_data = open(release_uri, headers) { |data| data.read } 
    122     package_id = release_data[/[?&]package_id=(\d+)/, 1] 
    123     raise "Couldn't get package id" unless package_id 
    124  
    125     first_file = true 
    126     release_id = "" 
    127  
    128     files.each do |filename| 
    129       basename  = File.basename(filename) 
    130       file_ext  = File.extname(filename) 
    131       file_data = File.open(filename, "rb") { |file| file.read } 
    132  
    133       puts "Releasing #{basename}..." 
    134  
    135       release_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    136         release_date = Time.now.strftime("%Y-%m-%d %H:%M") 
    137         type_map = { 
    138           ".zip"    => "3000", 
    139           ".tgz"    => "3110", 
    140           ".gz"     => "3110", 
    141           ".gem"    => "1400" 
    142         }; type_map.default = "9999" 
    143         type = type_map[file_ext] 
    144         boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor" 
    145  
    146         query_hash = if first_file then 
    147           { 
    148             "group_id" => group_id, 
    149             "package_id" => package_id, 
    150             "release_name" => RELEASE_NAME, 
    151             "release_date" => release_date, 
    152             "type_id" => type, 
    153             "processor_id" => "8000", # Any 
    154             "release_notes" => "", 
    155             "release_changes" => "", 
    156             "preformatted" => "1", 
    157             "submit" => "1" 
    158           } 
    159         else 
    160           { 
    161             "group_id" => group_id, 
    162             "release_id" => release_id, 
    163             "package_id" => package_id, 
    164             "step2" => "1", 
    165             "type_id" => type, 
    166             "processor_id" => "8000", # Any 
    167             "submit" => "Add This File" 
    168           } 
    169         end 
    170  
    171         query = "?" + query_hash.map do |(name, value)| 
    172           [name, URI.encode(value)].join("=") 
    173         end.join("&") 
    174  
    175         data = [ 
    176           "--" + boundary, 
    177           "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"", 
    178           "Content-Type: application/octet-stream", 
    179           "Content-Transfer-Encoding: binary", 
    180           "", file_data, "" 
    181           ].join("\x0D\x0A") 
    182  
    183         release_headers = headers.merge( 
    184           "Content-Type" => "multipart/form-data; boundary=#{boundary}" 
    185         ) 
    186  
    187         target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php" 
    188         http.post(target + query, data, release_headers) 
    189       end 
    190  
    191       if first_file then 
    192         release_id = release_response.body[/release_id=(\d+)/, 1] 
    193         raise("Couldn't get release id") unless release_id 
    194       end 
    195  
    196       first_file = false 
    197     end 
     90  for ext in %w( gem tgz zip ) 
     91    release_command = "rubyforge add_release #{PKG_NAME} #{PKG_NAME} 'REL #{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" 
     92    puts release_command 
     93    system(release_command) 
    19894  end 
    19995end 

  • branches/stable/actionpack/Rakefile

    r4194 r4204  
    137137 
    138138desc "Publish the release files to RubyForge." 
    139 task :release => [:package] do 
    140   files = ["gem", "tgz", "zip"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" } 
     139task :release => [ :package ] do 
     140  `rubyforge login` 
    141141 
    142   if RUBY_FORGE_PROJECT then 
    143     require 'net/http' 
    144     require 'open-uri' 
    145  
    146     project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/" 
    147     project_data = open(project_uri) { |data| data.read } 
    148     group_id = project_data[/[?&]group_id=(\d+)/, 1] 
    149     raise "Couldn't get group id" unless group_id 
    150  
    151     # This echos password to shell which is a bit sucky 
    152     if ENV["RUBY_FORGE_PASSWORD"] 
    153       password = ENV["RUBY_FORGE_PASSWORD"] 
    154     else 
    155       print "#{RUBY_FORGE_USER}@rubyforge.org's password: " 
    156       password = STDIN.gets.chomp 
    157     end 
    158  
    159     login_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    160       data = [ 
    161         "login=1", 
    162         "form_loginname=#{RUBY_FORGE_USER}", 
    163         "form_pw=#{password}" 
    164       ].join("&") 
    165       http.post("/account/login.php", data) 
    166     end 
    167  
    168     cookie = login_response["set-cookie"] 
    169     raise "Login failed" unless cookie 
    170     headers = { "Cookie" => cookie } 
    171  
    172     release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}" 
    173     release_data = open(release_uri, headers) { |data| data.read } 
    174     package_id = release_data[/[?&]package_id=(\d+)/, 1] 
    175     raise "Couldn't get package id" unless package_id 
    176  
    177     first_file = true 
    178     release_id = "" 
    179  
    180     files.each do |filename| 
    181       basename  = File.basename(filename) 
    182       file_ext  = File.extname(filename) 
    183       file_data = File.open(filename, "rb") { |file| file.read } 
    184  
    185       puts "Releasing #{basename}..." 
    186  
    187       release_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    188         release_date = Time.now.strftime("%Y-%m-%d %H:%M") 
    189         type_map = { 
    190           ".zip"    => "3000", 
    191           ".tgz"    => "3110", 
    192           ".gz"     => "3110", 
    193           ".gem"    => "1400" 
    194         }; type_map.default = "9999" 
    195         type = type_map[file_ext] 
    196         boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor" 
    197  
    198         query_hash = if first_file then 
    199           { 
    200             "group_id" => group_id, 
    201             "package_id" => package_id, 
    202             "release_name" => RELEASE_NAME, 
    203             "release_date" => release_date, 
    204             "type_id" => type, 
    205             "processor_id" => "8000", # Any 
    206             "release_notes" => "", 
    207             "release_changes" => "", 
    208             "preformatted" => "1", 
    209             "submit" => "1" 
    210           } 
    211         else 
    212           { 
    213             "group_id" => group_id, 
    214             "release_id" => release_id, 
    215             "package_id" => package_id, 
    216             "step2" => "1", 
    217             "type_id" => type, 
    218             "processor_id" => "8000", # Any 
    219             "submit" => "Add This File" 
    220           } 
    221         end 
    222  
    223         query = "?" + query_hash.map do |(name, value)| 
    224           [name, URI.encode(value)].join("=") 
    225         end.join("&") 
    226  
    227         data = [ 
    228           "--" + boundary, 
    229           "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"", 
    230           "Content-Type: application/octet-stream", 
    231           "Content-Transfer-Encoding: binary", 
    232           "", file_data, "" 
    233           ].join("\x0D\x0A") 
    234  
    235         release_headers = headers.merge( 
    236           "Content-Type" => "multipart/form-data; boundary=#{boundary}" 
    237         ) 
    238  
    239         target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php" 
    240         http.post(target + query, data, release_headers) 
    241       end 
    242  
    243       if first_file then 
    244         release_id = release_response.body[/release_id=(\d+)/, 1] 
    245         raise("Couldn't get release id") unless release_id 
    246       end 
    247  
    248       first_file = false 
    249     end 
     142  for ext in %w( gem tgz zip ) 
     143    release_command = "rubyforge add_release #{PKG_NAME} #{PKG_NAME} 'REL #{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" 
     144    puts release_command 
     145    system(release_command) 
    250146  end 
    251147end 

  • branches/stable/actionwebservice/Rakefile

    r4203 r4204  
    161161 
    162162desc "Publish the release files to RubyForge." 
    163 task :release => [:package] do 
    164   files = ["gem", "tgz", "zip"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" } 
     163task :release => [ :package ] do 
     164  `rubyforge login` 
    165165 
    166   if RUBY_FORGE_PROJECT then 
    167     require 'net/http' 
    168     require 'open-uri' 
    169  
    170     project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/" 
    171     project_data = open(project_uri) { |data| data.read } 
    172     group_id = project_data[/[?&]group_id=(\d+)/, 1] 
    173     raise "Couldn't get group id" unless group_id 
    174  
    175     # This echos password to shell which is a bit sucky 
    176     if ENV["RUBY_FORGE_PASSWORD"] 
    177       password = ENV["RUBY_FORGE_PASSWORD"] 
    178     else 
    179       print "#{RUBY_FORGE_USER}@rubyforge.org's password: " 
    180       password = STDIN.gets.chomp 
    181     end 
    182  
    183     login_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    184       data = [ 
    185         "login=1", 
    186         "form_loginname=#{RUBY_FORGE_USER}", 
    187         "form_pw=#{password}" 
    188       ].join("&") 
    189       http.post("/account/login.php", data) 
    190     end 
    191  
    192     cookie = login_response["set-cookie"] 
    193     raise "Login failed" unless cookie 
    194     headers = { "Cookie" => cookie } 
    195  
    196     release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}" 
    197     release_data = open(release_uri, headers) { |data| data.read } 
    198     package_id = release_data[/[?&]package_id=(\d+)/, 1] 
    199     raise "Couldn't get package id" unless package_id 
    200  
    201     first_file = true 
    202     release_id = "" 
    203  
    204     files.each do |filename| 
    205       basename  = File.basename(filename) 
    206       file_ext  = File.extname(filename) 
    207       file_data = File.open(filename, "rb") { |file| file.read } 
    208  
    209       puts "Releasing #{basename}..." 
    210  
    211       release_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    212         release_date = Time.now.strftime("%Y-%m-%d %H:%M") 
    213         type_map = { 
    214           ".zip"    => "3000", 
    215           ".tgz"    => "3110", 
    216           ".gz"     => "3110", 
    217           ".gem"    => "1400" 
    218         }; type_map.default = "9999" 
    219         type = type_map[file_ext] 
    220         boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor" 
    221  
    222         query_hash = if first_file then 
    223           { 
    224             "group_id" => group_id, 
    225             "package_id" => package_id, 
    226             "release_name" => RELEASE_NAME, 
    227             "release_date" => release_date, 
    228             "type_id" => type, 
    229             "processor_id" => "8000", # Any 
    230             "release_notes" => "", 
    231             "release_changes" => "", 
    232             "preformatted" => "1", 
    233             "submit" => "1" 
    234           } 
    235         else 
    236           { 
    237             "group_id" => group_id, 
    238             "release_id" => release_id, 
    239             "package_id" => package_id, 
    240             "step2" => "1", 
    241             "type_id" => type, 
    242             "processor_id" => "8000", # Any 
    243             "submit" => "Add This File" 
    244           } 
    245         end 
    246  
    247         query = "?" + query_hash.map do |(name, value)| 
    248           [name, URI.encode(value)].join("=") 
    249         end.join("&") 
    250  
    251         data = [ 
    252           "--" + boundary, 
    253           "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"", 
    254           "Content-Type: application/octet-stream", 
    255           "Content-Transfer-Encoding: binary", 
    256           "", file_data, "" 
    257           ].join("\x0D\x0A") 
    258  
    259         release_headers = headers.merge( 
    260           "Content-Type" => "multipart/form-data; boundary=#{boundary}" 
    261         ) 
    262  
    263         target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php" 
    264         http.post(target + query, data, release_headers) 
    265       end 
    266  
    267       if first_file then 
    268         release_id = release_response.body[/release_id=(\d+)/, 1] 
    269         raise("Couldn't get release id") unless release_id 
    270       end 
    271  
    272       first_file = false 
    273     end 
     166  for ext in %w( gem tgz zip ) 
     167    release_command = "rubyforge add_release #{PKG_NAME} #{PKG_NAME} 'REL #{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" 
     168    puts release_command 
     169    system(release_command) 
    274170  end 
    275171end 

  • branches/stable/activerecord/Rakefile

    r4194 r4204  
    171171 
    172172desc "Publish the release files to RubyForge." 
    173 task :release => [:package] do 
    174   files = ["gem", "tgz", "zip"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" } 
     173task :release => [ :package ] do 
     174  `rubyforge login` 
    175175 
    176   if RUBY_FORGE_PROJECT then 
    177     require 'net/http' 
    178     require 'open-uri' 
    179  
    180     project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/" 
    181     project_data = open(project_uri) { |data| data.read } 
    182     group_id = project_data[/[?&]group_id=(\d+)/, 1] 
    183     raise "Couldn't get group id" unless group_id 
    184  
    185     # This echos password to shell which is a bit sucky 
    186     if ENV["RUBY_FORGE_PASSWORD"] 
    187       password = ENV["RUBY_FORGE_PASSWORD"] 
    188     else 
    189       print "#{RUBY_FORGE_USER}@rubyforge.org's password: " 
    190       password = STDIN.gets.chomp 
    191     end 
    192  
    193     login_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    194       data = [ 
    195         "login=1", 
    196         "form_loginname=#{RUBY_FORGE_USER}", 
    197         "form_pw=#{password}" 
    198       ].join("&") 
    199       http.post("/account/login.php", data) 
    200     end 
    201  
    202     cookie = login_response["set-cookie"] 
    203     raise "Login failed" unless cookie 
    204     headers = { "Cookie" => cookie } 
    205  
    206     release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}" 
    207     release_data = open(release_uri, headers) { |data| data.read } 
    208     package_id = release_data[/[?&]package_id=(\d+)/, 1] 
    209     raise "Couldn't get package id" unless package_id 
    210  
    211     first_file = true 
    212     release_id = "" 
    213  
    214     files.each do |filename| 
    215       basename  = File.basename(filename) 
    216       file_ext  = File.extname(filename) 
    217       file_data = File.open(filename, "rb") { |file| file.read } 
    218  
    219       puts "Releasing #{basename}..." 
    220  
    221       release_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    222         release_date = Time.now.strftime("%Y-%m-%d %H:%M") 
    223         type_map = { 
    224           ".zip"    => "3000", 
    225           ".tgz"    => "3110", 
    226           ".gz"     => "3110", 
    227           ".gem"    => "1400" 
    228         }; type_map.default = "9999" 
    229         type = type_map[file_ext] 
    230         boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor" 
    231  
    232         query_hash = if first_file then 
    233           { 
    234             "group_id" => group_id, 
    235             "package_id" => package_id, 
    236             "release_name" => RELEASE_NAME, 
    237             "release_date" => release_date, 
    238             "type_id" => type, 
    239             "processor_id" => "8000", # Any 
    240             "release_notes" => "", 
    241             "release_changes" => "", 
    242             "preformatted" => "1", 
    243             "submit" => "1" 
    244           } 
    245         else 
    246           { 
    247             "group_id" => group_id, 
    248             "release_id" => release_id, 
    249             "package_id" => package_id, 
    250             "step2" => "1", 
    251             "type_id" => type, 
    252             "processor_id" => "8000", # Any 
    253             "submit" => "Add This File" 
    254           } 
    255         end 
    256  
    257         query = "?" + query_hash.map do |(name, value)| 
    258           [name, URI.encode(value)].join("=") 
    259         end.join("&") 
    260  
    261         data = [ 
    262           "--" + boundary, 
    263           "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"", 
    264           "Content-Type: application/octet-stream", 
    265           "Content-Transfer-Encoding: binary", 
    266           "", file_data, "" 
    267           ].join("\x0D\x0A") 
    268  
    269         release_headers = headers.merge( 
    270           "Content-Type" => "multipart/form-data; boundary=#{boundary}" 
    271         ) 
    272  
    273         target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php" 
    274         http.post(target + query, data, release_headers) 
    275       end 
    276  
    277       if first_file then 
    278         release_id = release_response.body[/release_id=(\d+)/, 1] 
    279         raise("Couldn't get release id") unless release_id 
    280       end 
    281  
    282       first_file = false 
    283     end 
     176  for ext in %w( gem tgz zip ) 
     177    release_command = "rubyforge add_release #{PKG_NAME} #{PKG_NAME} 'REL #{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" 
     178    puts release_command 
     179    system(release_command) 
    284180  end 
    285181end 

  • branches/stable/activesupport/Rakefile

    r4081 r4204  
    7272 
    7373desc "Publish the release files to RubyForge." 
    74 task :release => [:package] do 
    75   files = ["gem", "tgz", "zip"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" } 
     74task :release => [ :package ] do 
     75  `rubyforge login` 
    7676 
    77   if RUBY_FORGE_PROJECT then 
    78     require 'net/http' 
    79     require 'open-uri' 
    80  
    81     project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/" 
    82     project_data = open(project_uri) { |data| data.read } 
    83     group_id = project_data[/[?&]group_id=(\d+)/, 1] 
    84     raise "Couldn't get group id" unless group_id 
    85  
    86     # This echos password to shell which is a bit sucky 
    87     if ENV["RUBY_FORGE_PASSWORD"] 
    88       password = ENV["RUBY_FORGE_PASSWORD"] 
    89     else 
    90       print "#{RUBY_FORGE_USER}@rubyforge.org's password: " 
    91       password = STDIN.gets.chomp 
    92     end 
    93  
    94     login_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    95       data = [ 
    96         "login=1", 
    97         "form_loginname=#{RUBY_FORGE_USER}", 
    98         "form_pw=#{password}" 
    99       ].join("&") 
    100       http.post("/account/login.php", data) 
    101     end 
    102  
    103     cookie = login_response["set-cookie"] 
    104     raise "Login failed" unless cookie 
    105     headers = { "Cookie" => cookie } 
    106  
    107     release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}" 
    108     release_data = open(release_uri, headers) { |data| data.read } 
    109     package_id = release_data[/[?&]package_id=(\d+)/, 1] 
    110     raise "Couldn't get package id" unless package_id 
    111  
    112     first_file = true 
    113     release_id = "" 
    114  
    115     files.each do |filename| 
    116       basename  = File.basename(filename) 
    117       file_ext  = File.extname(filename) 
    118       file_data = File.open(filename, "rb") { |file| file.read } 
    119  
    120       puts "Releasing #{basename}..." 
    121  
    122       release_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    123         release_date = Time.now.strftime("%Y-%m-%d %H:%M") 
    124         type_map = { 
    125           ".zip"    => "3000", 
    126           ".tgz"    => "3110", 
    127           ".gz"     => "3110", 
    128           ".gem"    => "1400" 
    129         }; type_map.default = "9999" 
    130         type = type_map[file_ext] 
    131         boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor" 
    132  
    133         query_hash = if first_file then 
    134           { 
    135             "group_id" => group_id, 
    136             "package_id" => package_id, 
    137             "release_name" => RELEASE_NAME, 
    138             "release_date" => release_date, 
    139             "type_id" => type, 
    140             "processor_id" => "8000", # Any 
    141             "release_notes" => "", 
    142             "release_changes" => "", 
    143             "preformatted" => "1", 
    144             "submit" => "1" 
    145           } 
    146         else 
    147           { 
    148             "group_id" => group_id, 
    149             "release_id" => release_id, 
    150             "package_id" => package_id, 
    151             "step2" => "1", 
    152             "type_id" => type, 
    153             "processor_id" => "8000", # Any 
    154             "submit" => "Add This File" 
    155           } 
    156         end 
    157  
    158         query = "?" + query_hash.map do |(name, value)| 
    159           [name, URI.encode(value)].join("=") 
    160         end.join("&") 
    161  
    162         data = [ 
    163           "--" + boundary, 
    164           "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"", 
    165           "Content-Type: application/octet-stream", 
    166           "Content-Transfer-Encoding: binary", 
    167           "", file_data, "" 
    168           ].join("\x0D\x0A") 
    169  
    170         release_headers = headers.merge( 
    171           "Content-Type" => "multipart/form-data; boundary=#{boundary}" 
    172         ) 
    173  
    174         target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php" 
    175         http.post(target + query, data, release_headers) 
    176       end 
    177  
    178       if first_file then 
    179         release_id = release_response.body[/release_id=(\d+)/, 1] 
    180         raise("Couldn't get release id") unless release_id 
    181       end 
    182  
    183       first_file = false 
    184     end 
     77  for ext in %w( gem tgz zip ) 
     78    release_command = "rubyforge add_release #{PKG_NAME} #{PKG_NAME} 'REL #{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" 
     79    puts release_command 
     80    system(release_command) 
    18581  end 
    18682end 

  • branches/stable/railties/Rakefile

    r4203 r4204  
    313313 
    314314desc "Publish the release files to RubyForge." 
    315 task :release => [:gem] do 
    316   files = ["gem"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" } 
    317  
    318   if RUBY_FORGE_PROJECT then 
    319     require 'net/http' 
    320     require 'open-uri' 
    321  
    322     project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/" 
    323     project_data = open(project_uri) { |data| data.read } 
    324     group_id = project_data[/[?&]group_id=(\d+)/, 1] 
    325     raise "Couldn't get group id" unless group_id 
    326  
    327     # This echos password to shell which is a bit sucky 
    328     if ENV["RUBY_FORGE_PASSWORD"] 
    329       password = ENV["RUBY_FORGE_PASSWORD"] 
    330     else 
    331       print "#{RUBY_FORGE_USER}@rubyforge.org's password: " 
    332       password = STDIN.gets.chomp 
    333     end 
    334  
    335     login_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    336       data = [ 
    337         "login=1", 
    338         "form_loginname=#{RUBY_FORGE_USER}", 
    339         "form_pw=#{password}" 
    340       ].join("&") 
    341       http.post("/account/login.php", data) 
    342     end 
    343  
    344     cookie = login_response["set-cookie"] 
    345     raise "Login failed" unless cookie 
    346     headers = { "Cookie" => cookie } 
    347  
    348     release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}" 
    349     release_data = open(release_uri, headers) { |data| data.read } 
    350     package_id = release_data[/[?&]package_id=(\d+)/, 1] 
    351     raise "Couldn't get package id" unless package_id 
    352  
    353     first_file = true 
    354     release_id = "" 
    355  
    356     files.each do |filename| 
    357       basename  = File.basename(filename) 
    358       file_ext  = File.extname(filename) 
    359       file_data = File.open(filename, "rb") { |file| file.read } 
    360  
    361       puts "Releasing #{basename}..." 
    362  
    363       release_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    364         release_date = Time.now.strftime("%Y-%m-%d %H:%M") 
    365         type_map = { 
    366           ".zip"    => "3000", 
    367           ".tgz"    => "3110", 
    368           ".gz"     => "3110", 
    369           ".gem"    => "1400" 
    370         }; type_map.default = "9999" 
    371         type = type_map[file_ext] 
    372         boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor" 
    373  
    374         query_hash = if first_file then 
    375           { 
    376             "group_id" => group_id, 
    377             "package_id" => package_id, 
    378             "release_name" => RELEASE_NAME, 
    379             "release_date" => release_date, 
    380             "type_id" => type, 
    381             "processor_id" => "8000", # Any 
    382             "release_notes" => "", 
    383             "release_changes" => "", 
    384             "preformatted" => "1", 
    385             "submit" => "1" 
    386           } 
    387         else 
    388           { 
    389             "group_id" => group_id, 
    390             "release_id" => release_id, 
    391             "package_id" => package_id, 
    392             "step2" => "1", 
    393             "type_id" => type, 
    394             "processor_id" => "8000", # Any 
    395             "submit" => "Add This File" 
    396           } 
    397         end 
    398  
    399         query = "?" + query_hash.map do |(name, value)| 
    400           [name, URI.encode(value)].join("=") 
    401         end.join("&") 
    402  
    403         data = [ 
    404           "--" + boundary, 
    405           "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"", 
    406           "Content-Type: application/octet-stream", 
    407           "Content-Transfer-Encoding: binary", 
    408           "", file_data, "" 
    409           ].join("\x0D\x0A") 
    410  
    411         release_headers = headers.merge( 
    412           "Content-Type" => "multipart/form-data; boundary=#{boundary}" 
    413         ) 
    414  
    415         target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php" 
    416         http.post(target + query, data, release_headers) 
    417       end 
    418  
    419       if first_file then 
    420         release_id = release_response.body[/release_id=(\d+)/, 1] 
    421         raise("Couldn't get release id") unless release_id 
    422       end 
    423  
    424       first_file = false 
    425     end 
    426   end 
    427 end 
     315task :release => [ :gem ] do 
     316  `rubyforge login` 
     317  release_command = "rubyforge add_release #{PKG_NAME} #{PKG_NAME} 'REL #{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.gem" 
     318  puts release_command 
     319  system(release_command) 
     320end 

  • branches/stable/release.rb

    r4092 r4204  
    11#!/usr/local/bin/ruby 
    22 
     3VERSION  = ARGV.first 
    34PACKAGES = %w( activesupport activerecord actionpack actionmailer actionwebservice ) 
    4  
    5 unless ruby_forge_password = ARGV.first 
    6   print "rubyforge.org's password: " 
    7   ruby_forge_password = STDIN.gets.chomp 
    8 end 
    95 
    106# Checkout source 
    …… 
    1511 
    1612# Upload documentation 
    17 `cd release/rails/doc/api && scp -r * davidhh@wrath.rubyonrails.com:public_html/rails` 
    18 PACKAGES.each do |p|  
    19   `cd release/#{p} && echo "Publishing documentation for #{p}" && rake template=jamis pdoc` 
    20 end 
     13`cd release/rails/doc/api && scp -r * davidhh@wrath.rubyonrails.com:public_html/api` 
    2114 
    2215# Upload packages 
    2316(PACKAGES + %w(railties)).each do |p|  
    24   `cd release/#{p} && echo "Releasing #{p}" && RUBY_FORGE_PASSWORD=#{ruby_forge_password} rake release` 
     17  `cd release/#{p} && echo "Releasing #{p}" && rake release` 
    2518end 
    2619 
    2720# Upload rails tgz/zip 
     21`rubyforge add_release rails rails 'REL #{VERSION}' rails-#{VERSION}.tgz` 
     22`rubyforge add_release rails rails 'REL #{VERSION}' rails-#{VERSION}.zip` 
    2823 
    2924# Create SVN tag 
     25puts "Remeber to create SVN tag" 

  • trunk/actionmailer/Rakefile

    r4194 r4204  
    8585 
    8686desc "Publish the release files to RubyForge." 
    87 task :release => [:package] do 
    88   files = ["gem", "tgz", "zip"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" } 
     87task :release => [ :package ] do 
     88  `rubyforge login` 
    8989 
    90   if RUBY_FORGE_PROJECT then 
    91     require 'net/http' 
    92     require 'open-uri' 
    93  
    94     project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/" 
    95     project_data = open(project_uri) { |data| data.read } 
    96     group_id = project_data[/[?&]group_id=(\d+)/, 1] 
    97     raise "Couldn't get group id" unless group_id 
    98  
    99     # This echos password to shell which is a bit sucky 
    100     if ENV["RUBY_FORGE_PASSWORD"] 
    101       password = ENV["RUBY_FORGE_PASSWORD"] 
    102     else 
    103       print "#{RUBY_FORGE_USER}@rubyforge.org's password: " 
    104       password = STDIN.gets.chomp 
    105     end 
    106  
    107     login_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    108       data = [ 
    109         "login=1", 
    110         "form_loginname=#{RUBY_FORGE_USER}", 
    111         "form_pw=#{password}" 
    112       ].join("&") 
    113       http.post("/account/login.php", data) 
    114     end 
    115  
    116     cookie = login_response["set-cookie"] 
    117     raise "Login failed" unless cookie 
    118     headers = { "Cookie" => cookie } 
    119  
    120     release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}" 
    121     release_data = open(release_uri, headers) { |data| data.read } 
    122     package_id = release_data[/[?&]package_id=(\d+)/, 1] 
    123     raise "Couldn't get package id" unless package_id 
    124  
    125     first_file = true 
    126     release_id = "" 
    127  
    128     files.each do |filename| 
    129       basename  = File.basename(filename) 
    130       file_ext  = File.extname(filename) 
    131       file_data = File.open(filename, "rb") { |file| file.read } 
    132  
    133       puts "Releasing #{basename}..." 
    134  
    135       release_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    136         release_date = Time.now.strftime("%Y-%m-%d %H:%M") 
    137         type_map = { 
    138           ".zip"    => "3000", 
    139           ".tgz"    => "3110", 
    140           ".gz"     => "3110", 
    141           ".gem"    => "1400" 
    142         }; type_map.default = "9999" 
    143         type = type_map[file_ext] 
    144         boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor" 
    145  
    146         query_hash = if first_file then 
    147           { 
    148             "group_id" => group_id, 
    149             "package_id" => package_id, 
    150             "release_name" => RELEASE_NAME, 
    151             "release_date" => release_date, 
    152             "type_id" => type, 
    153             "processor_id" => "8000", # Any 
    154             "release_notes" => "", 
    155             "release_changes" => "", 
    156             "preformatted" => "1", 
    157             "submit" => "1" 
    158           } 
    159         else 
    160           { 
    161             "group_id" => group_id, 
    162             "release_id" => release_id, 
    163             "package_id" => package_id, 
    164             "step2" => "1", 
    165             "type_id" => type, 
    166             "processor_id" => "8000", # Any 
    167             "submit" => "Add This File" 
    168           } 
    169         end 
    170  
    171         query = "?" + query_hash.map do |(name, value)| 
    172           [name, URI.encode(value)].join("=") 
    173         end.join("&") 
    174  
    175         data = [ 
    176           "--" + boundary, 
    177           "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"", 
    178           "Content-Type: application/octet-stream", 
    179           "Content-Transfer-Encoding: binary", 
    180           "", file_data, "" 
    181           ].join("\x0D\x0A") 
    182  
    183         release_headers = headers.merge( 
    184           "Content-Type" => "multipart/form-data; boundary=#{boundary}" 
    185         ) 
    186  
    187         target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php" 
    188         http.post(target + query, data, release_headers) 
    189       end 
    190  
    191       if first_file then 
    192         release_id = release_response.body[/release_id=(\d+)/, 1] 
    193         raise("Couldn't get release id") unless release_id 
    194       end 
    195  
    196       first_file = false 
    197     end 
     90  for ext in %w( gem tgz zip ) 
     91    release_command = "rubyforge add_release #{PKG_NAME} #{PKG_NAME} 'REL #{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" 
     92    puts release_command 
     93    system(release_command) 
    19894  end 
    19995end 

  • trunk/actionpack/Rakefile

    r4194 r4204  
    137137 
    138138desc "Publish the release files to RubyForge." 
    139 task :release => [:package] do 
    140   files = ["gem", "tgz", "zip"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" } 
     139task :release => [ :package ] do 
     140  `rubyforge login` 
    141141 
    142   if RUBY_FORGE_PROJECT then 
    143     require 'net/http' 
    144     require 'open-uri' 
    145  
    146     project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/" 
    147     project_data = open(project_uri) { |data| data.read } 
    148     group_id = project_data[/[?&]group_id=(\d+)/, 1] 
    149     raise "Couldn't get group id" unless group_id 
    150  
    151     # This echos password to shell which is a bit sucky 
    152     if ENV["RUBY_FORGE_PASSWORD"] 
    153       password = ENV["RUBY_FORGE_PASSWORD"] 
    154     else 
    155       print "#{RUBY_FORGE_USER}@rubyforge.org's password: " 
    156       password = STDIN.gets.chomp 
    157     end 
    158  
    159     login_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    160       data = [ 
    161         "login=1", 
    162         "form_loginname=#{RUBY_FORGE_USER}", 
    163         "form_pw=#{password}" 
    164       ].join("&") 
    165       http.post("/account/login.php", data) 
    166     end 
    167  
    168     cookie = login_response["set-cookie"] 
    169     raise "Login failed" unless cookie 
    170     headers = { "Cookie" => cookie } 
    171  
    172     release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}" 
    173     release_data = open(release_uri, headers) { |data| data.read } 
    174     package_id = release_data[/[?&]package_id=(\d+)/, 1] 
    175     raise "Couldn't get package id" unless package_id 
    176  
    177     first_file = true 
    178     release_id = "" 
    179  
    180     files.each do |filename| 
    181       basename  = File.basename(filename) 
    182       file_ext  = File.extname(filename) 
    183       file_data = File.open(filename, "rb") { |file| file.read } 
    184  
    185       puts "Releasing #{basename}..." 
    186  
    187       release_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    188         release_date = Time.now.strftime("%Y-%m-%d %H:%M") 
    189         type_map = { 
    190           ".zip"    => "3000", 
    191           ".tgz"    => "3110", 
    192           ".gz"     => "3110", 
    193           ".gem"    => "1400" 
    194         }; type_map.default = "9999" 
    195         type = type_map[file_ext] 
    196         boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor" 
    197  
    198         query_hash = if first_file then 
    199           { 
    200             "group_id" => group_id, 
    201             "package_id" => package_id, 
    202             "release_name" => RELEASE_NAME, 
    203             "release_date" => release_date, 
    204             "type_id" => type, 
    205             "processor_id" => "8000", # Any 
    206             "release_notes" => "", 
    207             "release_changes" => "", 
    208             "preformatted" => "1", 
    209             "submit" => "1" 
    210           } 
    211         else 
    212           { 
    213             "group_id" => group_id, 
    214             "release_id" => release_id, 
    215             "package_id" => package_id, 
    216             "step2" => "1", 
    217             "type_id" => type, 
    218             "processor_id" => "8000", # Any 
    219             "submit" => "Add This File" 
    220           } 
    221         end 
    222  
    223         query = "?" + query_hash.map do |(name, value)| 
    224           [name, URI.encode(value)].join("=") 
    225         end.join("&") 
    226  
    227         data = [ 
    228           "--" + boundary, 
    229           "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"", 
    230           "Content-Type: application/octet-stream", 
    231           "Content-Transfer-Encoding: binary", 
    232           "", file_data, "" 
    233           ].join("\x0D\x0A") 
    234  
    235         release_headers = headers.merge( 
    236           "Content-Type" => "multipart/form-data; boundary=#{boundary}" 
    237         ) 
    238  
    239         target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php" 
    240         http.post(target + query, data, release_headers) 
    241       end 
    242  
    243       if first_file then 
    244         release_id = release_response.body[/release_id=(\d+)/, 1] 
    245         raise("Couldn't get release id") unless release_id 
    246       end 
    247  
    248       first_file = false 
    249     end 
     142  for ext in %w( gem tgz zip ) 
     143    release_command = "rubyforge add_release #{PKG_NAME} #{PKG_NAME} 'REL #{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" 
     144    puts release_command 
     145    system(release_command) 
    250146  end 
    251147end 

  • trunk/actionwebservice/Rakefile

    r4203 r4204  
    161161 
    162162desc "Publish the release files to RubyForge." 
    163 task :release => [:package] do 
    164   files = ["gem", "tgz", "zip"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" } 
     163task :release => [ :package ] do 
     164  `rubyforge login` 
    165165 
    166   if RUBY_FORGE_PROJECT then 
    167     require 'net/http' 
    168     require 'open-uri' 
    169  
    170     project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/" 
    171     project_data = open(project_uri) { |data| data.read } 
    172     group_id = project_data[/[?&]group_id=(\d+)/, 1] 
    173     raise "Couldn't get group id" unless group_id 
    174  
    175     # This echos password to shell which is a bit sucky 
    176     if ENV["RUBY_FORGE_PASSWORD"] 
    177       password = ENV["RUBY_FORGE_PASSWORD"] 
    178     else 
    179       print "#{RUBY_FORGE_USER}@rubyforge.org's password: " 
    180       password = STDIN.gets.chomp 
    181     end 
    182  
    183     login_response = Net::HTTP.start("rubyforge.org", 80) do |http| 
    184       data = [ 
    185         "login=1", 
    186         "form_loginname=#{RUBY_FORGE_USER}", 
    187         "form_pw=#{password}" 
    188       ].join("&") 
    189       http.post("/account/login.php", data) 
    190     end 
    191  
    192     cookie = login_response["set-cookie"] 
    193     raise "Login failed" unless cookie 
    194     headers = { "Cookie" => cookie }&nbs