bitballoon 0.0.4 → 0.0.5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bitballoon (0.0.3)
+    bitballoon (0.0.4)
       highline
       oauth2 (>= 0.9.2)
       slop

data/README.md

@@ -46,40 +46,65 @@ If you're not authenticating on behalf of a user you can authorize directly with
 bitballoon.authorize_from_credentials!
 ```
 
+Command Line Utility
+====================
+
+The BitBalloon gem comes with a handy command line utility for deploying and redeploying sites.
+
+To deploy the site in the current working directory:
+
+```ruby
+bitballoon deploy
+```
+
+The first time you deploy, you will be asked for your `client id` and `client secret`. After the deploy the tool will store an `access_token` and the `site_id` in `.bitballoon`. Next time you run the command the tool will redeploy the site using the stored `access_token`.
+
+You can also deploy a specific path:
+
+```ruby
+bitballoon deploy /path/to/my/site
+```
+
+Or a zip file:
+
+```ruby
+bitballoon deploy /path/to/my/site.zip
+```
+
 Sites
 =====
 
 Getting a list of all sites you have access to:
 
 ```ruby
-    bitballoon.sites.each do |site|
-      puts site.url
-    end
+bitballoon.sites.each do |site|
+  puts site.url
+end
 ```
 
 Getting a specific site by id:
 
 ```ruby
-    site = bitballoon.sites.get(id)
+site = bitballoon.sites.get(id)
 ```
 
 Creating a site from a directory:
 
 ```ruby
-    site = bitballoon.sites.create(:dir => "/tmp/my-site")
+site = bitballoon.sites.create(:dir => "/tmp/my-site")
 ```
 
 Creating a site from a zip file:
 
 ```ruby
-    site = bitballoon.sites.create(:zip => "/tmp/my-site.zip")
+site = bitballoon.sites.create(:zip => "/tmp/my-site.zip")
 ```
 
 Both methods will create the site and upload the files. The site will then be processing.
 
 ```ruby
-    site.state == "processing"
-    site.processing? == true
+site.state == "processing"
+site.processing? == true
 ```
 
 Refresh a site to update the state:
@@ -91,9 +116,25 @@ Refresh a site to update the state:
 Use `wait_until_ready` to wait until a site has finished processing.
 
 ```ruby
-    site = bitballoon.sites.create(:dir => "/tmp/my-site")
-    site.wait_for_ready
-    site.state == "ready"
+site = bitballoon.sites.create(:dir => "/tmp/my-site")
+site.wait_for_ready
+site.state == "ready"
+```
+
+Redeploy a site from a dir:
+
+```ruby
+site = bitballoon.sites.get(site_id)
+site.update(:dir => "/tmp/my-site")
+site.wait_for_ready
+```
+
+Redeploy a site from a zip file:
+
+```ruby
+site = bitballoon.sites.get(site_id)
+site.update(:zip => "/tmp/my-site.zip")
+site.wait_for_ready
 ```
 
 Update the name of the site (its subdomain), the custom domain and the notification email for form submissions:

data/bin/bitballoon

@@ -12,33 +12,44 @@ opts = Slop.parse do
   command 'deploy' do
     run do |opts, args|
       path = args.first ? File.expand_path(args.first) : Dir.getwd
+      zip = path.match(/\.zip$/)
 
       raise "File or dir doesn't exist: #{path}" unless File.exist?(path)
-      raise "Can't deploy a single file" if File.file?(path) && !path.match(/\.zip$/)
+      raise "Can't deploy a single file" if File.file?(path) && !zip
 
+      credentials_path = File.expand_path(".bitballoon", zip ? File.dirname(path) : path)
 
-
-      credentials_path = File.exist?(File.expand_path(".bitballoon")) ? File.expand_path(".bitballoon") : "#{Dir.home}/.bitballoon"
       if File.exist?(credentials_path)
-        access_token = JSON.parse(File.read(credentials_path))['access_token']
-        client = BitBalloon::Client.new(:access_token => access_token)
+        credentials = JSON.parse(File.read(credentials_path))
+        client = BitBalloon::Client.new(:access_token => credentials['access_token'])
       else
         puts "Please enter your BitBalloon API Credentials (if you don't have any, you can create your credentials at https://www.bitballoon.com/applications)"
         client_id = ask("Client ID:")
         client_secret = ask("Client Secret:")
         client = BitBalloon::Client.new(:client_id => client_id, :client_secret => client_secret)
         client.authorize_from_credentials!
-        File.open(credentials_path, "w") do |file|
-          file.write(JSON.generate(:access_token => client.access_token))
-        end
-        puts "Wrote access token to '#{credentials_path}'"
+        credentials = {'access_token' => client.access_token}
       end
 
-      site = path.match(/\.zip$/) ? client.sites.create(:zip => path) : client.sites.create(:dir => path)
+      attributes = zip ? {:zip => path} : {:dir => path}
+
+      if credentials['site_id']
+        site = client.sites.get(credentials['site_id'])
+        site.update(attributes)
+      else
+        site = client.sites.create(attributes)
+      end
       puts "Waiting for processing"
       site.wait_for_ready do |site|
         puts "Polling site: #{site.id} - #{site.state}"
       end
+
+      credentials['site_id'] = site.id
+
+      File.open(credentials_path, "w") do |file|
+        file.write(JSON.generate(credentials))
+      end
+
       puts "Site deployed: #{site.url}"
     end
   end

data/lib/bitballoon.rb

@@ -8,5 +8,6 @@ require "bitballoon/forms"
 require "bitballoon/submissions"
 require "bitballoon/files"
 require "bitballoon/snippets"
+require "bitballoon/deploys"
 
 module BitBalloon; end

data/lib/bitballoon/client.rb

@@ -5,6 +5,12 @@ module BitBalloon
     ENDPOINT    = ENV['OAUTH_CLIENT_API_URL'] || 'https://www.bitballoon.com'
     API_VERSION = "v1"
 
+    class BitBalloonError < StandardError; end
+    class NotFoundError < BitBalloonError; end
+    class ConnectionError < BitBalloonError; end
+    class InternalServerError < BitBalloonError; end
+    class AuthenticationError < BitBalloonError; end
+
     attr_accessor :client_id, :client_secret, :oauth, :access_token
 
     def initialize(options)
@@ -45,13 +51,31 @@ module BitBalloon
     end
 
     def request(verb, path, opts={}, &block)
-      raise "Authorize with BitBalloon before making requests" unless oauth_token
+      raise AuthenticationError, "Authorize with BitBalloon before making requests" unless oauth_token
+
       oauth_token.request(verb, ::File.join("/api", API_VERSION, path), opts, &block)
+    rescue OAuth2::Error => e
+      case e.response.status
+      when 401
+        raise AuthenticationError, message_for(e, "Authentication Error")
+      when 404
+        raise NotFoundError, message_for(e, "Not Found")
+      when 500
+        raise InternalServerError, message_for(e, "Internal Server Error")
+      else
+        raise BitBalloonError, message_for(e, "OAuth2 Error")
+      end
+    rescue Faraday::Error::ConnectionFailed => e
+      raise ConnectionError, message_for(e, "Connection Error")
     end
 
     private
     def oauth_token
       @oauth_token ||= access_token && OAuth2::AccessToken.new(oauth, access_token)
     end
+
+    def message_for(error, default)
+      error.message.strip == "" ? default : error.message
+    end
   end
 end

data/lib/bitballoon/deploy.rb

@@ -0,0 +1,13 @@
+module BitBalloon
+  class Deploy < Model
+    fields :id, :state, :premium, :claimed, :name, :custom_domain, :url,
+           :admin_url, :deploy_url, :screenshot_url, :created_at, :updated_at,
+           :user_id, :required
+
+    def restore
+      response = client.request(:post, File.join(path, "restore"))
+      process(response.parsed)
+      self
+    end
+  end
+end

data/lib/bitballoon/deploys.rb

@@ -0,0 +1,7 @@
+require "bitballoon/deploy"
+
+module BitBalloon
+  class Deploys < CollectionProxy
+    path "/deploys"
+  end
+end

data/lib/bitballoon/model.rb

@@ -1,6 +1,6 @@
 module BitBalloon
   class Model
-    attr_reader :client
+    attr_reader :client, :attributes
 
     def self.fields(*names)
       return @fields if names.empty?

data/lib/bitballoon/site.rb

@@ -3,8 +3,8 @@ require 'digest/sha1'
 module BitBalloon
   class Site < Model
     fields :id, :state, :premium, :claimed, :name, :custom_domain, :url,
-           :admin_url, :screenshot_url, :created_at, :updated_at, :user_id,
-           :required
+           :admin_url, :deploy_url, :screenshot_url, :created_at, :updated_at,
+           :user_id, :required, :error_message
 
     def upload_dir(dir)
       return unless state == "uploading"
@@ -25,14 +25,19 @@ module BitBalloon
     end
 
     def ready?
-      state == "ready"
+      state == "current"
+    end
+
+    def error?
+      state == "error"
     end
 
     def wait_for_ready(timeout = 900)
       start = Time.now
-      while !ready?
+      while !(ready?)
         sleep 5
         refresh
+        raise "Error processing site: #{error_message}" if error?
         yield(self) if block_given?
         raise "Timeout while waiting for ready" if Time.now - start > timeout
       end
@@ -40,8 +45,13 @@ module BitBalloon
     end
 
     def update(attributes)
-      response = client.request(:put, path, :body => mutable_attributes(attributes))
-      process(response.parsed)
+      if attributes[:zip] || attributes[:dir]
+        site = collection.new(client).create(attributes.merge(:id => id))
+        process(site.attributes)
+      else
+        response = client.request(:put, path, :body => mutable_attributes(attributes))
+        process(response.parsed)
+      end
       self
     end
 

data/lib/bitballoon/sites.rb

@@ -6,15 +6,18 @@ module BitBalloon
     path "/sites"
 
     def create(attributes = {})
+      site_id = attributes.delete(:id)
+      path    = site_id ? "/sites/#{site_id}" : "/sites"
+      method  = site_id ? :put : :post
       if attributes[:dir]
         dir = attributes[:dir]
-        response = client.request(:post, "/sites", :body => JSON.generate({:files => inventory(dir)}), :headers => {"Content-Type" => "application/json"})
+        response = client.request(method, path, :body => JSON.generate({:files => inventory(dir)}), :headers => {"Content-Type" => "application/json"})
         Site.new(client, response.parsed).tap do |site|
           site.upload_dir(dir)
         end
       elsif attributes[:zip]
         ::File.open(attributes[:zip]) do |file|
-          response = client.request(:post, "/sites", :body => {
+          response = client.request(method, path, :body => {
             :zip => Faraday::UploadIO.new(file, 'application/zip')
           })
           Site.new(client, response.parsed)

data/lib/bitballoon/version.rb

@@ -1,3 +1,3 @@
 module BitBalloon
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitballoon
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-27 00:00:00.000000000 Z
+date: 2013-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oauth2
@@ -109,6 +109,8 @@ files:
 - lib/bitballoon.rb
 - lib/bitballoon/client.rb
 - lib/bitballoon/collection_proxy.rb
+- lib/bitballoon/deploy.rb
+- lib/bitballoon/deploys.rb
 - lib/bitballoon/file.rb
 - lib/bitballoon/files.rb
 - lib/bitballoon/form.rb