fog-maestrodev 1.7.0.20121114190951 → 1.8.0.20130109172219

data/.gitignore

@@ -6,17 +6,17 @@
 .bundle
 .DS_Store
 .idea
+.yardoc
 /tests/.fog
 bin/*
 !bin/fog
-!bin/rdoc
 .fog
 coverage
 doc/*
 docs/_site/*
 docs/about/supported_services.markdown
 Gemfile.lock
-rdoc
+yardoc
 pkg
 spec/credentials.yml
 vendor/*

data/README.md

@@ -1,12 +1,15 @@
 ![fog](http://geemus.s3.amazonaws.com/fog.png)
 
-fog is the Ruby cloud computing library, top to bottom:
+fog is the Ruby cloud services library, top to bottom:
 
 * Collections provide a simplified interface, making clouds easier to work with and switch between.
 * Requests allow power users to get the most out of the features of each individual cloud.
 * Mocks make testing and integrating a breeze.
 
 [![Build Status](https://secure.travis-ci.org/fog/fog.png?branch=master)](http://travis-ci.org/fog/fog)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/fog/fog)
+[![Gem Version](https://fury-badge.herokuapp.com/rb/fog.png)](http://badge.fury.io/rb/fog)
+[![Dependency Status](https://gemnasium.com/fog/fog.png)](https://gemnasium.com/fog/fog)
 
 ## Getting Started
 
@@ -15,14 +18,16 @@ fog is the Ruby cloud computing library, top to bottom:
 Now type `fog` to try stuff, confident that fog will let you know what to do. 
 Here is an example of wading through server creation for Amazon Elastic Compute Cloud:
 
-    >> server = Compute[:aws].servers.create
-    ArgumentError: image_id is required for this operation
+```ruby
+server = Compute[:aws].servers.create
+# => ArgumentError: image_id is required for this operation
 
-    >> server = Compute[:aws].servers.create(:image_id => 'ami-5ee70037')
-    <Fog::AWS::EC2::Server [...]>
+server = Compute[:aws].servers.create(:image_id => 'ami-5ee70037')
+# => <Fog::AWS::EC2::Server [...]>
 
-    >> server.destroy # cleanup after yourself or regret it, trust me
-    true
+server.destroy # cleanup after yourself or regret it, trust me
+# => true
+```
 
 ## Collections
 
@@ -30,8 +35,10 @@ A high level interface to each cloud is provided through collections, such as `i
 You can see a list of available collections by calling `collections` on the connection object. 
 You can try it out using the `fog` command:
 
-    >> Compute[:aws].collections
-    [:addresses, :directories, ..., :volumes, :zones]
+```ruby
+Compute[:aws].collections
+# => [:addresses, :directories, ..., :volumes, :zones]
+```
 
 Some collections are available across multiple providers:
 
@@ -48,21 +55,23 @@ Collections share basic CRUD type operations, such as:
 
 As an example, we'll try initializing and persisting a Rackspace Cloud server:
 
-    require 'fog'
+```ruby
+require 'fog'
 
-    compute = Fog::Compute.new(
-      :provider           => 'Rackspace',
-      :rackspace_api_key  => key,
-      :rackspace_username => username
-    )
+compute = Fog::Compute.new(
+  :provider           => 'Rackspace',
+  :rackspace_api_key  => key,
+  :rackspace_username => username
+)
 
-    # boot a gentoo server (flavor 1 = 256, image 3 = gentoo 2008.0)
-    server = compute.servers.create(:flavor_id => 1, :image_id => 3, :name => 'my_server')
-    server.wait_for { ready? } # give server time to boot
+# boot a gentoo server (flavor 1 = 256, image 3 = gentoo 2008.0)
+server = compute.servers.create(:flavor_id => 1, :image_id => 3, :name => 'my_server')
+server.wait_for { ready? } # give server time to boot
 
-    # DO STUFF
+# DO STUFF
 
-    server.destroy # cleanup after yourself or regret it, trust me
+server.destroy # cleanup after yourself or regret it, trust me
+```
 
 ## Models
 
@@ -78,7 +87,9 @@ As you might imagine, testing code using Fog can be slow and expensive, constant
 Mocking allows skipping this overhead by providing an in memory representation resources as you make requests.
 Enabling mocking easy to use, before you run other commands, simply run:
 
-    Fog.mock!
+```ruby
+Fog.mock!
+```
 
 Then proceed as usual, if you run into unimplemented mocks, fog will raise an error and as always contributions are welcome!
 
@@ -100,40 +111,40 @@ It will return an [excon](http://github.com/geemus/excon) response, which has `b
 Play around and use the console to explore or check out [fog.io](http://fog.io) for more details and examples. 
 Once you are ready to start scripting fog, here is a quick hint on how to make connections without the command line thing to help you.
 
-    # create a compute connection
-    compute = Fog::Compute.new(:provider => 'AWS', :aws_access_key_id => ACCESS_KEY_ID, :aws_secret_access_key => SECRET_ACCESS_KEY)
-    # compute operations go here
+```ruby
+# create a compute connection
+compute = Fog::Compute.new(:provider => 'AWS', :aws_access_key_id => ACCESS_KEY_ID, :aws_secret_access_key => SECRET_ACCESS_KEY)
+# compute operations go here
 
-    # create a storage connection
-    storage = Fog::Storage.new(:provider => 'AWS', :aws_access_key_id => ACCESS_KEY_ID, :aws_secret_access_key => SECRET_ACCESS_KEY)
-    # storage operations go here
+# create a storage connection
+storage = Fog::Storage.new(:provider => 'AWS', :aws_access_key_id => ACCESS_KEY_ID, :aws_secret_access_key => SECRET_ACCESS_KEY)
+# storage operations go here
+```
 
 geemus says: "That should give you everything you need to get started, but let me know if there is anything I can do to help!"
 
 ## Contributing
 
-* Find something you would like to work on. For suggestions look for the `easy`, `medium` and `hard` tags in the [issues](https://github.com/fog/fog/issues)
+* Find something you would like to work on.
+  * Look for anything you can help with in the [issue tracker](https://github.com/fog/fog/issues).
+  * Look at the [code quality metrics](https://codeclimate.com/github/fog/fog) for anything you can help clean up.
+  * Or anything else!
 * Fork the project and do your work in a topic branch.
-* Add a config at `~/.fog` for the component you want to test.
+  * Make sure your changes will work on both Ruby 1.8.7 and Ruby 1.9
+* Add a config at `tests/.fog` for the component you want to test.
 * Add shindo tests to prove your code works and run all the tests using `bundle exec rake`.
-* Rebase your branch against fog/fog to make sure everything is up to date.
+* Rebase your branch against `fog/fog` to make sure everything is up to date.
 * Commit your changes and send a pull request.
 
 ## Additional Resources
 
 [fog.io](http://fog.io)
 
-## Sponsorship
-
-![Engine Yard](http://www.engineyard.com/images/logo.png)
-
-All new work on fog is sponsored by [Engine Yard](http://engineyard.com)
-
 ## Copyright
 
 (The MIT License)
 
-Copyright (c) 2010 [geemus (Wesley Beary)](http://github.com/geemus)
+Copyright (c) 2013 [geemus (Wesley Beary)](http://github.com/geemus)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/RELEASE.md

@@ -0,0 +1,39 @@
+# Release process
+
+This is fog's current release process, documented so people know what is
+currently done.
+
+## Versioning
+
+fog uses semantic versioning (http://semver.org/)
+
+## When we release
+
+Releases occur monthly and are manually handled by fog's Benevolent
+Dictator Wes (@geemus).
+
+To request a new release please raise an issue.
+
+## Prepare the release
+
+* Ensure the code is passing on the CI server [![Build Status](https://secure.travis-ci.org/fog/fog.png?branch=master)](http://travis-ci.org/fog/fog)
+* Ensure the code is passing for live tests (Requires Credentials for all
+services)
+* Ensure working on **master**
+* Update the version number (`lib/fog/version.rb`)
+* Run `rake changelog` to update `changelog.txt`
+* Run `rake release` to prepare the release which does:
+  * Prepares the release (`rake release:prepare`)
+    * Builds the gem
+    * Tags the commit
+    * Creates commits for version
+  * Publishes the release (`rake release:publish`)
+    * Pushes commit and tag to Github (Requires Credentials)
+    * Pushes gem to Rubygems (Requires Credentials)
+
+## Announce the release
+
+Once the release is prepared and uploaded it needs to be announced.
+
+* Send an email to https://groups.google.com/forum/?fromgroups#!forum/ruby-fog
+* Tweet as @fog on Twitter (Requires Credentials)

data/Rakefile

@@ -1,8 +1,8 @@
 require 'bundler/setup'
 require 'date'
 require 'rubygems'
-require 'rdoc/task'
 require 'rubygems/package_task'
+require 'yard'
 require File.dirname(__FILE__) + '/lib/fog'
 
 #############################################################################
@@ -16,9 +16,7 @@ def name
 end
 
 def version
-  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
-  v = line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
-  "#{v}.#{Time.now.getutc.strftime "%Y%m%d%H%M%S"}"
+  "#{Fog::VERSION}.#{Time.now.getutc.strftime "%Y%m%d%H%M%S"}"
 end
 
 def date
@@ -51,46 +49,15 @@ end
 GEM_NAME = "#{name}"
 task :default => :test
 
-namespace :test do
-  task :dynect do
-    [false].each do |mock|
-      sh("export FOG_MOCK=#{mock} && bundle exec shindont tests/dns/requests/dynect")
-      #sh("export FOG_MOCK=#{mock} && bundle exec shindont tests/dns/models/")
-    end
-  end
-end
-
-task :test do
-  Rake::Task[:mock_tests].invoke
-end
+require "tasks/test_task"
+Fog::Rake::TestTask.new
 
-def tests(mocked)
-  Formatador.display_line
-  start = Time.now.to_i
-  threads = []
-  Thread.main[:results] = []
-  Fog.providers.each do |key, value|
-    threads << Thread.new do
-      Thread.main[:results] << {
-        :provider => value,
-        :success  => sh("export FOG_MOCK=#{mocked} && bundle exec shindont +#{key}")
-      }
+namespace :test do
+  task :vsphere do
+    [true].each do |mock|
+      sh("export FOG_MOCK=#{mock} && bundle exec shindont tests/vsphere")
     end
   end
-  threads.each do |thread|
-    thread.join
-  end
-  Formatador.display_table(Thread.main[:results].sort {|x,y| x[:provider] <=> y[:provider]})
-  Formatador.display_line("[bold]FOG_MOCK=#{mocked}[/] tests completed in [bold]#{Time.now.to_i - start}[/] seconds")
-  Formatador.display_line
-end
-
-task :mock_tests do
-  tests(true)
-end
-
-task :real_tests do
-  tests(false)
 end
 
 task :nuke do
@@ -118,14 +85,6 @@ task :nuke do
   end
 end
 
-require 'rdoc/task'
-RDoc::Task.new do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "#{name} #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
 desc "Open an irb session preloaded with this library"
 task :console do
   sh "irb -rubygems -r ./lib/#{name}.rb"
@@ -137,18 +96,44 @@ end
 #
 #############################################################################
 
-task :release => :build do
-  unless `git branch` =~ /^\* master$/
-    puts "You must be on the master branch to release!"
-    exit!
+task :release => ["release:prepare", "release:publish"]
+
+namespace :release do
+  task :preflight do
+    unless `git branch` =~ /^\* master$/
+      puts "You must be on the master branch to release!"
+      exit!
+    end
+    if `git tag` =~ /^\* v#{version}$/
+      puts "Tag v#{version} already exists!"
+      exit!
+    end
+  end
+
+  task :prepare => :preflight do
+    Rake::Task[:build].invoke
+    sh "gem install pkg/#{name}-#{version}.gem"
+    Rake::Task[:git_mark_release].invoke
+  end
+
+  task :publish do
+    Rake::Task[:git_push_release].invoke
+    Rake::Task[:gem_push].invoke
   end
-  sh "gem install pkg/#{name}-#{version}.gem"
+end
+
+task :git_mark_release do
   sh "git commit --allow-empty -a -m 'Release #{version}'"
   sh "git tag v#{version}"
+end
+
+task :git_push_release do
   sh "git push origin master"
   sh "git push origin v#{version}"
+end
+
+task :gem_push do
   sh "gem push pkg/#{name}-#{version}.gem"
-  Rake::Task[:docs].invoke
 end
 
 task :build => :gemspec do
@@ -173,7 +158,7 @@ task :gemspec => :validate do
 end
 
 task :validate do
-  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
+  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}", "lib/tasks"]
   unless libfiles.empty?
     puts "Directory `lib` should only contain a `#{name}.rb` file and `#{name}` dir."
     exit!
@@ -184,261 +169,12 @@ task :validate do
   end
 end
 
-task :changelog do
-  timestamp = Time.now.utc.strftime('%m/%d/%Y')
-  sha = `git log | head -1`.split(' ').last
-  changelog = ["#{version} #{timestamp} #{sha}"]
-  changelog << ('=' * changelog[0].length)
-  changelog << ''
-
-  require 'multi_json'
-  github_repo_data = Fog::JSON.decode(Excon.get('https://api.github.com/repos/fog/fog').body)
-  data = github_repo_data.reject {|key, value| !['forks', 'open_issues', 'watchers'].include?(key)}
-  github_collaborator_data = Fog::JSON.decode(Excon.get('https://api.github.com/repos/fog/fog/collaborators').body)
-  data['collaborators'] = github_collaborator_data.length
-  rubygems_data = Fog::JSON.decode(Excon.get('https://rubygems.org/api/v1/gems/fog.json').body)
-  data['downloads'] = rubygems_data['downloads']
-  stats = []
-  for key in data.keys.sort
-    stats << "'#{key}' => #{data[key]}"
-  end
-  changelog << "Stats! { #{stats.join(', ')} }"
-  changelog << ''
-
-  last_sha = `cat changelog.txt | head -1`.split(' ').last
-  shortlog = `git shortlog #{last_sha}..HEAD`
-  changes = {}
-  committers = {}
-  for line in shortlog.split("\n")
-    if line =~ /^\S/
-      committer = line.split(' (', 2).first
-      committers[committer] = 0
-    elsif line =~ /^\s*((Merge.*)|(Release.*))?$/
-      # skip empty lines, Merge and Release commits
-    else
-      unless line[-1..-1] == '.'
-        line << '.'
-      end
-      line.lstrip!
-      line.gsub!(/^\[([^\]]*)\] /, '')
-      tag = $1 || 'misc'
-      changes[tag] ||= []
-      changes[tag] << (line << ' thanks ' << committer)
-      committers[committer] += 1
-    end
-  end
-
-  for committer, commits in committers.to_a.sort {|x,y| y[1] <=> x[1]}
-    if [
-        'Aaron Suggs',
-        'Brian Hartsock',
-        'Christopher Oliver',
-        'Decklin Foster',
-        'Dylan Egan',
-        'geemus',
-        'Henry Addison',
-        'Kevin Menard',
-        'Lincoln Stoll',
-        'Luqman Amjad',
-        'Michael Zeng',
-        'Nick Osborn',
-        'nightshade427',
-        'Patrick Debois',
-        'Stepan G. Fedorov',
-        'Wesley Beary'
-      ].include?(committer)
-      next
-    end
-    changelog << "MVP! #{committer}"
-    changelog << ''
-    break
-  end
-
-  for tag in changes.keys.sort
-    changelog << ('[' << tag << ']')
-    for commit in changes[tag]
-      changelog << ('  ' << commit)
-    end
-    changelog << ''
-  end
-
-  old_changelog = File.read('changelog.txt')
-  File.open('changelog.txt', 'w') do |file|
-    file.write(changelog.join("\n"))
-    file.write("\n\n")
-    file.write(old_changelog)
-  end
-end
-
-task :docs do
-  Rake::Task[:supported_services_docs].invoke
-  Rake::Task[:upload_fog_io].invoke
-  Rake::Task[:upload_rdoc].invoke
-
-  # connect to storage provider
-  Fog.credential = :geemus
-  storage = Fog::Storage.new(:provider => 'AWS')
-  directory = storage.directories.new(:key => 'fog.io')
-  # write base index with redirect to new version
-  directory.files.create(
-    :body         => redirecter('latest'),
-    :content_type => 'text/html',
-    :key          => 'index.html',
-    :public       => true
-  )
-
-  Formatador.display_line
+# Include Yard tasks for rake yard
+YARDOC_LOCATION = "doc"
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb', "README"]
+  t.options = ["--output-dir", YARDOC_LOCATION, "--title", "#{name} #{version}"]
 end
 
-task :supported_services_docs do
-  support, shared = {}, []
-  for key, values in Fog.services
-    unless values.length == 1
-      shared |= [key]
-      values.each do |value|
-        support[value] ||= {}
-        support[value][key] = '+'
-      end
-    else
-      value = values.first
-      support[value] ||= {}
-      support[value][:other] ||= []
-      support[value][:other] << key
-    end
-  end
-  shared.sort! {|x,y| x.to_s <=> y.to_s}
-  columns = [:provider] + shared + [:other]
-  data = []
-  for key in support.keys.sort {|x,y| x.to_s <=> y.to_s}
-    data << { :provider => key }.merge!(support[key])
-  end
-
-  table = ''
-  table << "<table border='1'>\n"
-
-  table << "  <tr>"
-  for column in columns
-    table << "<th>#{column}</th>"
-  end
-  table << "</tr>\n"
-
-  for datum in data
-    table << "  <tr>"
-    for column in columns
-      if value = datum[column]
-        case value
-        when Array
-          table << "<td>#{value.join(', ')}</td>"
-        when '+'
-          table << "<td style='text-align: center;'>#{value}</td>"
-        else
-          table << "<th>#{value}</th>"
-        end
-      else
-        table << "<td></td>"
-      end
-    end
-    table << "</tr>\n"
-  end
-
-  table << "</table>\n"
-
-  File.open('docs/about/supported_services.markdown', 'w') do |file|
-    file.puts <<-METADATA
----
-layout: default
-title:  Supported Services
----
-
-METADATA
-    file.puts(table)
-  end
-end
-
-task :upload_fog_io do
-  # connect to storage provider
-  Fog.credential = :geemus
-  storage = Fog::Storage.new(:provider => 'AWS')
-  directory = storage.directories.new(:key => 'fog.io')
-
-  # build the docs locally
-  sh "jekyll docs docs/_site"
-
-  # write web page files to versioned 'folder'
-  for file_path in Dir.glob('docs/_site/**/*')
-    next if File.directory?(file_path)
-    file_name = file_path.gsub('docs/_site/', '')
-    key = '' << version << '/' << file_name
-    Formatador.redisplay(' ' * 128)
-    Formatador.redisplay("Uploading [bold]#{key}[/]")
-    if File.extname(file_name) == '.html'
-      # rewrite links with version
-      body = File.read(file_path)
-      body.gsub!(/vX.Y.Z/, 'v' << version)
-      body.gsub!(/='\//, %{='/} << version << '/')
-      body.gsub!(/="\//, %{="/} << version << '/')
-      content_type = 'text/html'
-      directory.files.create(
-        :body         => redirecter(key),
-        :content_type => 'text/html',
-        :key          => 'latest/' << file_name,
-        :public       => true
-      )
-    else
-      body = File.open(file_path)
-      content_type = nil # leave it up to mime-types
-    end
-    directory.files.create(
-      :body         => body,
-      :content_type => content_type,
-      :key          => key,
-      :public       => true
-    )
-  end
-  Formatador.redisplay(' ' * 128)
-  Formatador.redisplay("Uploaded docs/_site\n")
-end
-
-task :upload_rdoc do
-  # connect to storage provider
-  Fog.credential = :geemus
-  storage = Fog::Storage.new(:provider => 'AWS')
-  directory = storage.directories.new(:key => 'fog.io')
-
-  # write rdoc files to versioned 'folder'
-  Rake::Task[:rdoc].invoke
-  for file_path in Dir.glob('rdoc/**/*')
-    next if File.directory?(file_path)
-    file_name = file_path.gsub('rdoc/', '')
-    key = '' << version << '/rdoc/' << file_name
-    Formatador.redisplay(' ' * 128)
-    Formatador.redisplay("Uploading [bold]#{key}[/]")
-    directory.files.create(
-      :body         => File.open(file_path),
-      :key          => key,
-      :public       => true
-    )
-  end
-  Formatador.redisplay(' ' * 128)
-  directory.files.create(
-    :body         => redirecter("#{version}/rdoc/index.html"),
-    :content_type => 'text/html',
-    :key          => 'latest/rdoc/index.html',
-    :public       => true
-  )
-  Formatador.redisplay("Uploaded rdoc\n")
-end
-
-def redirecter(path)
-  redirecter = <<-HTML
-<!doctype html>
-<head>
-<title>fog</title>
-<meta http-equiv="REFRESH" content="0;url=http://fog.io/#{path}">
-</head>
-<body>
-  <a href="http://fog.io/#{path}">redirecting to lastest (#{path})</a>
-</body>
-</html>
-HTML
-end
+require "tasks/changelog_task"
+Fog::Rake::ChangelogTask.new