google_storage 0.0.3

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea
+
+

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in google_storage.gemspec
+gemspec

data/README.textile

@@ -0,0 +1,110 @@
+h1. Google Storage using API v2
+
+I wrote this gem because the only google storage gems I could find already written were either written a while ago and only set up to use the old
+version of Google's API or they were dependent on Gems that don't run properly on... dare I say it... windows.. :)  Apologies, I'm without choice
+at the moment, but anyways, this gem should run fine on all platforms and I've tried to keep dependencies to a minimum. Let me know if you find
+any bugs though ok and feel free to contribute.
+
+Google Storage is still a little experimental at the moment and the responses back from google differ quite a bit from each other.
+I've tried to parse all of these different responses and turn them into a fairly common type of response object though.
+
+h2. Setup Guide
+
+There's a couple of steps to follow in order to setup this gem. The new Google Storage APIv2 uses OAuth 2.0 to authenticate requests, you can read up
+more on the nitty gritty if you like here: "Google's OAuth2 Guide":http://code.google.com/apis/accounts/docs/OAuth2.html
+
+I'll try and add client side support also once this gem is up and running properly, but for the moment it's only setup to support server side web
+applications.
+
+But it's also possible to run this gem from the command line if you want.
+
+
+h2. Install the google_storage Gem
+
+Include the google_storage gem in your Gemfile and install config files
+<pre>gem "google_storage"
+bundle install
+</pre>
+Then in your Rails application directory run:
+<pre>rails generate google_storage:install
+</pre>
+This will generate some rake tasks a google_storage.yml file in your config directory.
+<pre>/Application/config/google_storage.yml
+/Application/lib/tasks/google_storage.task
+</pre>
+
+
+
+h2. Setup your Google Project Client ID's
+
+Visit "Google Storage":http://code.google.com/apis/storage/ and select activate Google Storage.
+If you haven't already got a project set up, it'll prompt you to create one.
+
+When you have access to your Google APIs Console, you need to enable Google Storage. When you select enable, you'll be shown terms and conditions
+and you'll then need to setup billing. They have full pricing details there for you to check out as well but I think it's pretty reasonable..
+
+Create a client ID for your project
+On the left menu select "API Access" and then "Create an OAuth 2.0 client ID"
+Enter your project's name and brand information.
+
+Select Application type = Web Application and enter your site's information. If you're using localhost and running
+locally make sure you include the port number you're using as well.
+
+
+h2. Enter your Client ID details into your google_storage.yml
+
+This is the example google_storage.yml file that is copied into your config directory of your rails application.
+
+Follow the steps to obtain a refresh token from google.
+
+<pre>
+#Replace the following example ids with your own
+
+google_config:
+  x-goog-project-id: 825628431245
+
+#Client ID for web applications
+web_applications:
+  client_id: 825628431245.apps.googleusercontent.com
+  client_secret: lpNYX5SPFDB6N-40lyMIPlQn
+  redirect_uris: 'http://localhost:3000/example'
+  js_origins: 'http://localhost:3000'
+
+#refresh_token: replace this line with a refresh token from google, read below on how to get one
+
+#You need to acquire a refresh token from google so that the google_storage gem
+#can acquire access tokens whenever it needs to make new requests
+
+# 1. Make sure you've signed up for Google Storage and filled in the above client ID details
+#    for your web application first
+#
+# 2. Depending on how much access you want to grant to your application run
+#    ONE of the following from your applications root directory. If you intend to be able to create and
+#    destroy objects and buckets and also be able to set permissions then use full_control
+#
+#           rake gs:grant:read_only
+#           rake gs:grant:read_write
+#           rake gs:grant:full_control
+#
+# 3. Step 2 will generate a URL for you. Copy and paste the URL into a browser and you should be prompted
+#    by google to authorize the request by logging into your browser using the google email account you setup
+#    your google storage account with
+#
+# 4. When you 'allow access' you'll be redirected back to the redirect URL you setup in your client ID
+#    Your redirect URL should now include an authorization code. It'll look something like this:
+#    http://localhost:3000/example?code=4/WvlklnjtybhRJpaKpmDYrzIhAzyx
+#
+# 5. Copy that code from your URL and run the following rake task from your application directory
+#
+#           rake gs:refresh_token['paste_your_auth_code_here']
+#  Example: rake gs:refresh_token['4/WvlklnjtybhRJpaKpmDYrzIhAzyx']
+#
+# 6. If everything worked you should see something that looks like the following:
+#
+#           refresh_token: 1/x4X-U57snRMkLIWWYHWLCXPbfcnyGsdfx04sWAiG_1k
+#
+# 7. Copy and paste the refresh_token into this file. Your application should now be able to make calls to your
+#    Google Storage API
+</pre>
+
+Once you've acquired your refresh_token you can now make calls to the API. Refer to the examples dir on how to use.

data/Rakefile

@@ -0,0 +1,3 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+

data/examples/examples.rb

@@ -0,0 +1,60 @@
+### Configuration ###
+#
+#   require "google_storage"
+#
+#   The following will look for google_storage.yml in your rails config directory
+#     gs_client = GoogleStorage::Client.new
+#
+#   Otherwise you can pass in the path to the google_storage.yml
+#     gs_client = GoogleStorage::Client.new(:config_yml => 'C:/example_path/google_storage.yml')
+#
+### Service Requests ###
+#
+#   GET Service
+#     gs_client.list_buckets
+#
+### Bucket Requests ###
+#
+#   GET Access Control List for Bucket
+#     gs_client.list_acls_for_bucket('bucket_name')
+#     gs_client.bucket_acls('bucket_name')
+#
+#   PUT Bucket
+#     gs_client.create_bucket('bucket_name')                                <-- private bucket
+#     gs_client.create_bucket('bucket_name', :x_goog_acl => 'public-read')  <-- public bucket
+#
+#   GET Bucket
+#     gs_client.get_bucket('bucket_name')
+#     gs_client.bucket_contents('bucket_name')
+#
+#   DELETE Bucket
+#     gs_client.delete_bucket('bucket_name')
+#
+### Object Requests ###
+#
+#   GET Access Control List for Object
+#     gs_client.list_acls_for_object('bucket_name', 'object_name')
+#     gs_client.object_acls('bucket_name', 'object_name')
+#
+#   GET Object
+#     gs_client.get_object('bucket_name', 'object_name')
+#     gs_client.get_object('bucket_name', 'object_name', :write_to_file => '/tmp/example/file.jpg')
+#
+#   POST Object
+#    !!!! NOT ADDING POST METHOD AT THIS STAGE AS REQUIRES USE OF API V1 USING LEGACY ACCESS KEY
+#    !!!! USE PUT METHOD INSTEAD TO UPLOAD FILES
+#
+#   PUT Object
+#     gs_client.put_object('bucket_name', 'object_name', :data => File.read('/tmp/example/file.jpg'), :x_goog_acl => 'public-read')
+#     gs_client.put_object('bucket_name', 'object_name', :path_to_file => '/tmp/example/file.jpg')
+#
+#   HEAD Object
+#     gs_client.head_object('bucket_name', 'object_name')
+#
+#   DELETE Object
+#     gs_client.delete_object('bucket_name', 'object_name')
+
+
+
+
+

data/google_storage.gemspec

@@ -0,0 +1,19 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "google_storage/version"
+
+Gem::Specification.new do |s|
+  s.name        = "google_storage"
+  s.version     = GoogleStorage::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Lucas Hills"]
+  s.email       = ["lucas@lucashills.com"]
+  s.homepage    = "https://github.com/2potatocakes/google_storage"
+  s.summary     = "Google Storage for Developers is a RESTful service for storing and accessing your data on Google's infrastructure"
+  s.description = "A Ruby client library for using the new Google Storage API v2 using OAuth2.0"
+  s.files       = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency("crack", "~> 0.1.1")
+  s.require_paths = ["lib"]
+  s.extra_rdoc_files = ["README.textile"]
+end

data/lib/generators/google_storage/install/install_generator.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module GoogleStorage
+  # Copies a google_storage.yml file into your applications config directory and a rake file
+  # into your lib/tasks directory
+
+  class InstallGenerator < Rails::Generators::Base
+    desc "Copies a google_storage.yml file into your application"
+    source_root File.expand_path('../../../templates', __FILE__)
+
+    "Copies a google_storage.yml file into your applications config directory and a rake file into lib/tasks"
+    def generate_layout
+      copy_file        'google_storage.yml', 'config/google_storage.yml'
+      copy_file        'google_storage.rake', 'lib/tasks/google_storage.rake'
+    end
+
+  end
+end

data/lib/generators/templates/google_storage.rake

@@ -0,0 +1,27 @@
+require 'google_storage'
+
+namespace :gs do
+  client = GoogleStorage::Client.new
+
+  namespace :grant do
+    desc "Google Storage URL to grant 'read only' access to your storage account"
+    task :read_only do
+      puts client.authorization_url(:read_only)
+    end
+
+    desc "Google Storage URL to grant 'read/write' access to your storage account"
+    task :read_write do
+      puts client.authorization_url(:read_write)
+    end
+
+    desc "Google Storage URL to grant 'read only' access to your storage account"
+    task :full_control do
+      puts client.authorization_url(:full_control)
+    end
+  end
+
+  desc "Acquire Google Storage refresh token"
+  task :refresh_token, :auth_code do |t, args|
+    puts "refresh_token: #{client.acquire_refresh_token(args[:auth_code])}"
+  end
+end

data/lib/generators/templates/google_storage.yml

@@ -0,0 +1,48 @@
+#Replace the following example ids with your own
+
+google_config:
+  x-goog-project-id: 825628431245
+
+#Client ID for web applications
+web_applications:
+  client_id: 825628431245.apps.googleusercontent.com
+  client_secret: lpNYX5SPFDB6N-40lyMIPlQn
+  redirect_uris: 'http://localhost:3000/example'
+  js_origins: 'http://localhost:3000'
+
+#refresh_token: replace this line with a refresh token from google, read below on how to get one
+
+#You need to acquire a refresh token from google so that the google_storage gem
+#can acquire access tokens whenever it needs to make new requests
+
+# 1. Make sure you've signed up for Google Storage and filled in the above client ID details
+#    for your web application first
+#
+# 2. Depending on how much access you want to grant to your application run
+#    ONE of the following from your applications root directory. If you intend to be able to create and
+#    destroy objects and buckets and also be able to set permissions then use full_control
+#
+#           rake gs:grant:read_only
+#           rake gs:grant:read_write
+#           rake gs:grant:full_control
+#
+# 3. Step 2 will generate a URL for you. Copy and paste the URL into a browser and you should be prompted
+#    by google to authorize the request by logging into your browser using the google email account you setup
+#    your google storage account with
+#
+# 4. When you 'allow access' you'll be redirected back to the redirect URL you setup in your client ID
+#    Your redirect URL should now include an authorization code. It'll look something like this:
+#    http://localhost:3000/example?code=4/WvlklnjtybhRJpaKpmDYrzIhAzyx
+#
+# 5. Copy that code from your URL and run the following rake task from your application directory
+#
+#           rake gs:refresh_token['paste_your_auth_code_here']
+#  Example: rake gs:refresh_token['4/WvlklnjtybhRJpaKpmDYrzIhAzyx']
+#
+# 6. If everything worked you should see something that looks like the following:
+#
+#           refresh_token: 1/x4X-U57snRMkLIWWYHWLCXPbfcnyGsdfx04sWAiG_1k
+#
+# 7. Copy and paste the refresh_token into this file. Your application should now be able to make calls to your
+#    Google Storage API
+

data/lib/google_storage/bucket.rb

@@ -0,0 +1,76 @@
+
+module GoogleStorage
+  class Client
+
+    def list_buckets(options={})
+      options[:send_goog_project_id] = true
+      resp = get(nil, '/', options)
+      resp_obj = Crack::XML.parse(resp.body)
+      if resp_obj["ListAllMyBucketsResult"]
+        resp_obj[:success] = true
+        resp_obj[:buckets] = resp_obj["ListAllMyBucketsResult"]["Buckets"]["Bucket"]
+        resp_obj[:raw] = Crack::XML.parse(resp.body)
+        resp_obj.each_key {|key| resp_obj.delete(key) unless key == :success || key == :buckets || key == :raw }
+      end
+      return resp_obj
+    end
+
+    def list_acls_for_bucket(bucket, options={})
+      resp = get(bucket, '/?acl', options)
+      resp_obj = Crack::XML.parse(resp.body)
+      if resp_obj["AccessControlList"]
+        resp_obj[:success] = true
+        resp_obj[:bucket_name] = bucket
+        resp_obj[:acl] = resp_obj["AccessControlList"]
+        resp_obj[:raw] = Crack::XML.parse(resp.body)
+        resp_obj.each_key {|key| resp_obj.delete(key) unless key == :success || key == :bucket_name || key == :acl || key == :raw }
+      end
+      return resp_obj
+    end
+
+    alias :bucket_acls :list_acls_for_bucket
+
+    def create_bucket(bucket, options={})
+      options[:send_goog_project_id] = true
+      resp = put(bucket, '/', options)
+      resp_obj = Crack::XML.parse(resp.body)
+      if resp.code == "200"
+        resp_obj.clear
+        resp_obj[:success] = true
+        resp_obj[:bucket_name] = bucket
+        resp_obj[:message] = "Bucket created"
+      end
+      return resp_obj
+    end
+
+    def get_bucket(bucket, options={})
+      resp = get(bucket, '/', options)
+      resp_obj = Crack::XML.parse(resp.body)
+      if resp.code == "200"
+        resp_obj[:success] = true
+        resp_obj[:bucket_name] = bucket
+        contents = resp_obj["ListBucketResult"]["Contents"] ? Array.new : nil
+        resp_obj["ListBucketResult"]["Contents"].is_a?(Array) ? \
+          (contents = resp_obj["ListBucketResult"]["Contents"]) : \
+          (contents[0] = resp_obj["ListBucketResult"]["Contents"]) unless contents.nil?
+        resp_obj[:contents] = contents
+        resp_obj[:raw] = Crack::XML.parse(resp.body)
+        resp_obj.each_key {|key| resp_obj.delete(key) unless key == :success || key == :bucket_name || key == :contents || key == :raw  }
+      end
+      return resp_obj
+    end
+
+    alias :bucket_contents :get_bucket
+
+    def delete_bucket(bucket, options={})
+      resp = delete(bucket, '/', options)
+      return Crack::XML.parse(resp.body) unless resp.code == "204"
+      resp_obj = {}
+      resp_obj[:success] = true
+      resp_obj[:bucket_name] = bucket
+      resp_obj[:message] = "Bucket deleted"
+      return resp_obj
+    end
+
+  end
+end

data/lib/google_storage/client.rb

@@ -0,0 +1,111 @@
+require 'google_storage/request'
+require 'google_storage/token'
+require 'google_storage/bucket'
+require 'google_storage/object'
+require 'yaml'
+
+module GoogleStorage
+  
+  class Client
+    
+    def initialize(options = {})
+
+      if (options[:config_yml] && !options[:config_yml].nil?) || (defined?(Rails.root) && File.exists?(File.join(Rails.root, 'config', 'google_storage.yml')))
+        config_path = options[:config_yml] ? File.expand_path(options[:config_yml]) : File.join(Rails.root, 'config', 'google_storage.yml')
+      end
+
+      raise " \nCan't find a google_storage.yml file to initialise with..
+\nIf running inside a Rails Application
+Please run: rails generate google_storage:install
+To generate a google_storage.yml file in your config directory
+\nIf running manually within a script or whatever
+Initialise GoogleStorage with a path to your config yml file
+Example: GoogleStorage::Client.new(:config_yml => 'path to your google storage yml')
+\nIf running a rake task try passing: path='path to your google storage yml'
+\n\n" unless config_path && File.exists?(config_path)
+
+      config_yml = YAML::load(File.open(config_path))
+
+      @project_id     = config_yml['google_config']['x-goog-project-id']
+
+      @client_id      = config_yml['web_applications']['client_id']
+      @client_secret  = config_yml['web_applications']['client_secret']
+      @client_secret.force_encoding("UTF-8")
+      @refresh_token  = config_yml['refresh_token'] if config_yml['refresh_token']
+
+      #TODO Add support for individual permission types
+      if config_yml['google_storage_ids']
+        @gsid_you       = config_yml['google_storage_ids']['you'] if config_yml['google_storage_ids']['you']
+        @gsid_owners    = config_yml['google_storage_ids']['owners'] if config_yml['google_storage_ids']['owners']
+        @gsid_editors   = config_yml['google_storage_ids']['editors'] if config_yml['google_storage_ids']['editors']
+        @gsid_team      = config_yml['google_storage_ids']['team'] if config_yml['google_storage_ids']['team']
+      end
+
+      #TODO - make redirect_uri's support multiple urls
+      @redirect_uri   = config_yml['web_applications']['redirect_uris']
+      #TODO - maybe add support for API v1 as well... but probably not..
+      @api_version    = options[:x_goog_api_version] ? options[:x_goog_api_version] : 2
+      @debug          = options[:debug]
+      @timeout        = options[:timeout]
+      @host           = options[:host] ? options[:host] : 'commondatastorage.googleapis.com'
+    end
+
+    def google_storage_id(id)
+      case id
+        when :you
+          @gsid_you
+        when :owners
+          @gsid_owners
+        when :editors
+          @gsid_editors
+        when :team
+          @gsid_team
+      end
+    end
+
+    private
+      
+      def get(bucket, path, options={})
+        http_request(Net::HTTP::Get, bucket, path, options)
+      end
+      
+      def put(bucket, path, options={})
+        http_request(Net::HTTP::Put, bucket, path, options)
+      end
+      
+      def delete(bucket, path, options={})
+        http_request(Net::HTTP::Delete, bucket, path, options)
+      end
+      
+      def head(bucket, path, options={})
+        http_request(Net::HTTP::Head, bucket, path, options)
+      end
+
+      def post_request(host, path, token, options={})
+        params = options.delete(:params) || {}
+        headers = options.delete(:headers) || {}
+        params[:"client_id"]      = @client_id
+        params[:"client_secret"]  = @client_secret
+        params[:"grant_type"]     = options['grant_type']
+
+        case options['grant_type']
+          when 'authorization_code'
+            params[:"code"]           = token
+            params[:"redirect_uri"]   = @redirect_uri
+          when 'refresh_token'
+            params[:"refresh_token"]  = token
+        end
+
+        construct_post_request(host, path, headers, params, options)
+      end
+      
+      def http_request(method, bucket, path, options={})
+        host = bucket ? "#{bucket}.#{@host}" : @host
+        params = options.delete(:params) || {}
+        headers = options.delete(:headers) || {}
+        construct_http_request(host, path, method, headers, params, options)
+      end
+      
+  end
+end
+   

data/lib/google_storage/object.rb

@@ -0,0 +1,107 @@
+
+require 'digest/md5'
+
+module GoogleStorage
+  class Client
+
+    def get_object(bucket, filename, options={})
+      filename.gsub!(/^\//, "")
+      resp = get(bucket, "/#{filename}", options)
+      return Crack::XML.parse(resp.body) unless resp.code == "200"
+      resp_obj = {}
+      if options[:write_to_file]
+        begin
+          File.open(options[:write_to_file], 'wb') {|f| f.write(resp.body) }
+        rescue Exception => msg
+          return {:error => msg}
+        end
+        resp_obj.clear
+        resp_obj[:success]      = true
+        resp_obj[:message]      = "File created"
+        resp_obj[:path_to_file] = options[:write_to_file]
+        return resp_obj
+      end
+      resp_obj[:success]   = true
+      resp_obj[:filename] = filename
+      resp_obj[:body]     = resp.body
+      resp_obj[:type]     = resp.header["content-type"]
+      resp_obj[:size]     = resp.header["content-length"]
+
+      return resp_obj
+    end
+
+    def put_object(bucket, filename, options={})
+      filename.gsub!(/^\//, "")
+      if options[:path_to_file]
+        begin
+          uploaded_file = File.open(options[:path_to_file])
+          if uploaded_file.respond_to?(:get_input_stream)
+            uploaded_file.get_input_stream { |io| @data = io.read }
+          else
+            uploaded_file.binmode
+            @data = uploaded_file.read
+          end
+        rescue Exception => msg
+          return {:error => msg}
+        end
+        options[:data] = @data
+      end
+      resp = put(bucket, "/#{filename}", options)
+      public_file = (options[:x_goog_acl] && options[:x_goog_acl].match(/public/))
+      return Crack::XML.parse(resp.body) unless resp.code == "200"
+      resp_obj = {}
+      resp_obj[:success]      = true
+      resp_obj[:message]      = "Object added successfully"
+      resp_obj[:filename]     = filename
+      resp_obj[:content_type] = options[:content_type]
+      resp_obj[:url]          = public_file ? "http://#{@host}/#{bucket}/#{filename}" : \
+                                              "https://sandbox.google.com/storage/#{bucket}/#{filename}"
+      resp_obj[:url_type]     = public_file ? "public" : "private"
+      return resp_obj
+    end
+
+    def list_acls_for_object(bucket, filename, options={})
+      filename.gsub!(/^\//, "")
+      resp = get(bucket, "/#{filename}?acl", options)
+      resp_obj = Crack::XML.parse(resp.body)
+      if resp_obj["AccessControlList"]
+        resp_obj[:success] = true
+        resp_obj[:object_name] = filename
+        resp_obj[:acl] = resp_obj["AccessControlList"]
+        resp_obj[:raw] = Crack::XML.parse(resp.body)
+        resp_obj.each_key {|key| resp_obj.delete(key) unless key == :success || key == :object_name || key == :acl || key == :raw }
+      end
+      return resp_obj
+    end
+
+    alias :object_acls :list_acls_for_object
+
+    def head_object(bucket, filename, options={})
+      filename.gsub!(/^\//, "")
+      resp = head(bucket, "/#{filename}", options)
+      return resp.header unless resp.code == "200"
+      resp_obj = {}
+      resp_obj[:success]          = true
+      resp_obj[:filename]         = filename
+      resp_obj[:last_modified]    = resp.header['last-modified'] if resp.header['last-modified']
+      resp_obj[:etag]             = resp.header['etag'] if resp.header['etag']
+      resp_obj[:content_length]   = resp.header['content-length'] if resp.header['content-length']
+      resp_obj[:content_type]     = resp.header['content-type'] if resp.header['content-type']
+      resp_obj[:cache_control]    = resp.header['cache-control'] if resp.header['cache-control']
+      resp_obj[:date]             = resp.header['date'] if resp.header['date']
+      return resp_obj
+    end
+
+    alias :object_head :head_object
+
+    def delete_object(bucket, filename, options={})
+      filename.gsub!(/^\//, "")
+      resp = delete(bucket, "/#{filename}", options)
+      return Crack::XML.parse(resp.body) unless resp.code == "204"
+      resp_obj = {}
+      resp_obj[:success]          = true
+      resp_obj[:message]          = "Object deleted successfully"
+      return resp_obj
+    end
+  end
+end

data/lib/google_storage/request.rb

@@ -0,0 +1,81 @@
+require 'net/https'
+require 'cgi'
+
+module GoogleStorage
+  class Client
+
+    def construct_post_request(host, path, headers={}, params={}, options={})
+      headers["Host"]           = host
+      headers["Date"]           = Time.now.utc.strftime('%a, %d %b %Y %H:%M:%S GMT')
+      headers["Content-Type"]   = 'application/x-www-form-urlencoded'
+      headers["Content-Length"] = "0"
+      Crack::JSON.parse(_post_http_request(host, path, params, headers, options[:data]))
+    end
+
+    def construct_http_request(host, path, method, headers={}, params={}, options={})
+      raise "\nYou need to acquire a refresh_token before you can make requests to the Google API\n" unless @refresh_token
+      headers["Host"]               = host
+      headers["Date"]               = Time.now.utc.strftime('%a, %d %b %Y %H:%M:%S GMT')
+      headers["Content-Type"]       = options[:content_type] ? options[:content_type] : 'application/x-www-form-urlencoded'
+      headers["Content-Length"]     = (options[:data] ? options[:data].size : 0).to_s
+      headers["x-goog-api-version"] = @api_version
+      headers["x-goog-project-id"]  = @project_id if options[:send_goog_project_id]
+      headers["Authorization"]      = 'OAuth ' + self.refresh_access_token(@refresh_token)["access_token"]
+      param_string                  = params.empty? ? '' : '?' + params_to_data_string(params)
+      headers["Range"]              = options[:range] if options[:range]
+      headers["If-Match"]           = options[:filename] if options[:filename]
+      headers["If-Modified-Since"]  = options[:if_modified_since] if options[:if_modified_since]
+      headers["If-None-Match"]      = options[:if_none_match] if options[:if_none_match]
+      headers["If-Unmodified-Since"]= options[:if_modified_since] if options[:if_modified_since]
+      headers["Content-MD5"]        = options[:md5] if options[:md5]
+      headers["x-goog-acl"]         = options[:x_goog_acl] if options[:x_goog_acl]
+
+      _http_request(host, path, method, headers, param_string, options[:data])
+    end
+    
+    private
+      def _post_http_request(host, path, params, headers, data=nil)
+        http = Net::HTTP.new(host, 443)
+        http.use_ssl = true
+        http.set_debug_output $stderr if @debug
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        data ||= params_to_data_string(params)
+        resp = http.post(path, data, headers)
+
+        return resp.body
+      end
+
+
+      def _http_request(host, path, method, headers, param_string, data=nil)
+        http = Net::HTTP.new(host, 443)
+        http.use_ssl = true
+        http.set_debug_output $stderr if @debug
+        http.read_timeout = @timeout ? @timeout : 15
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        req = method.new(path + param_string)
+          headers.each do |key, value|
+            req[key.to_s] = value
+          end
+
+        response = http.start { http.request(req, data) }
+        return response
+        rescue Timeout::Error
+          $stderr.puts "Timeout accessing #{path}: #{$!}"
+          nil
+        rescue
+          $stderr.puts "Error accessing #{path}: #{$!}"
+          nil
+      end
+
+      def params_to_data_string(params)
+        return "" if params.empty?
+        esc_params = params.collect do |p|
+          encoded = (CGI::escape(p[0].to_s) + "=" + CGI::escape(p[1].to_s))
+          encoded.gsub('+', '%20')
+        end
+        "#{esc_params.join('&')}"
+      end
+  end
+end

data/lib/google_storage/token.rb

@@ -0,0 +1,31 @@
+module GoogleStorage
+  class Client
+
+    def authorization_url(scope)
+      scope_url = case scope
+        when :read_only
+          'https://www.googleapis.com/auth/devstorage.read_only'
+        when :read_write
+          'https://www.googleapis.com/auth/devstorage.read_write'
+        when :full_control
+          'https://www.googleapis.com/auth/devstorage.full_control'
+        else
+          'https://www.google.com/m8/feeds/'
+      end
+      "https://accounts.google.com/o/oauth2/auth?client_id=#{@client_id}&redirect_uri=#{@redirect_uri}&scope=#{scope_url}&response_type=code"
+    end
+
+    def acquire_refresh_token(token, options={})
+      options['grant_type'] = 'authorization_code'
+      response = post_request('accounts.google.com', '/o/oauth2/token', token, options)
+      return response["refresh_token"] if response["refresh_token"]
+      "Failed to acquire a refresh token. Something went wrong. Try getting a new Auth code."
+    end
+
+    def refresh_access_token(token, options={})
+      options['grant_type'] = 'refresh_token'
+      post_request('accounts.google.com', '/o/oauth2/token', token, options)
+    end
+
+  end
+end

data/lib/google_storage/version.rb

@@ -0,0 +1,3 @@
+module GoogleStorage
+  VERSION = "0.0.3"
+end

data/lib/google_storage.rb

@@ -0,0 +1,9 @@
+
+require 'crack'
+require 'google_storage/client'
+
+module GoogleStorage
+
+
+end
+

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: google_storage
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Lucas Hills
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-06-24 00:00:00.000000000 +10:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: crack
+  requirement: &9643716 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *9643716
+description: A Ruby client library for using the new Google Storage API v2 using OAuth2.0
+email:
+- lucas@lucashills.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.textile
+files:
+- .gitignore
+- Gemfile
+- README.textile
+- Rakefile
+- examples/examples.rb
+- google_storage.gemspec
+- lib/generators/google_storage/install/install_generator.rb
+- lib/generators/templates/google_storage.rake
+- lib/generators/templates/google_storage.yml
+- lib/google_storage.rb
+- lib/google_storage/bucket.rb
+- lib/google_storage/client.rb
+- lib/google_storage/object.rb
+- lib/google_storage/request.rb
+- lib/google_storage/token.rb
+- lib/google_storage/version.rb
+has_rdoc: true
+homepage: https://github.com/2potatocakes/google_storage
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Google Storage for Developers is a RESTful service for storing and accessing
+  your data on Google's infrastructure
+test_files: []