fog-google 0.1.3 → 0.2.0

data/lib/fog/storage/google_xml/requests/delete_object.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Storage
+    class GoogleXML
+      class Real
+        # Delete an object from Google Storage
+        #
+        # ==== Parameters
+        # * bucket_name<~String> - Name of bucket containing object to delete
+        # * object_name<~String> - Name of object to delete
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * status<~Integer> - 204
+        def delete_object(bucket_name, object_name)
+          request(:expects    => 204,
+                  :headers    => {},
+                  :host       => "#{bucket_name}.#{@host}",
+                  :idempotent => true,
+                  :method     => "DELETE",
+                  :path       => Fog::Google.escape(object_name))
+        end
+      end
+
+      class Mock
+        def delete_object(bucket_name, object_name)
+          response = Excon::Response.new
+          if bucket = data[:buckets][bucket_name]
+            if object = bucket[:objects][object_name]
+              response.status = 204
+              bucket[:objects].delete(object_name)
+            else
+              response.status = 404
+              raise(Excon::Errors.status_error({ :expects => 204 }, response))
+            end
+          else
+            response.status = 404
+            raise(Excon::Errors.status_error({ :expects => 204 }, response))
+          end
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/{google/requests/storage → storage/google_xml/requests}/get_bucket.rb

@@ -1,10 +1,8 @@
-require 'pp'
+require "pp"
 module Fog
   module Storage
-    class Google
+    class GoogleXML
       class Real
-        require 'fog/google/parsers/storage/get_bucket'
-
         # List information about objects in an Google Storage bucket
         #
         # ==== Parameters
@@ -37,66 +35,58 @@ module Fog
         #       * 'Size'<~Integer> - Size of object
         #
         def get_bucket(bucket_name, options = {})
-          unless bucket_name
-            raise ArgumentError.new('bucket_name is required')
-          end
-          request({
-            :expects  => 200,
-            :headers  => {},
-            :host     => "#{bucket_name}.#{@host}",
-            :idempotent => true,
-            :method   => 'GET',
-            :parser   => Fog::Parsers::Storage::Google::GetBucket.new,
-            :query    => options
-          })
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
+          request(:expects  => 200,
+                  :headers  => {},
+                  :host     => "#{bucket_name}.#{@host}",
+                  :idempotent => true,
+                  :method   => "GET",
+                  :parser   => Fog::Parsers::Storage::Google::GetBucket.new,
+                  :query    => options)
         end
       end
 
       class Mock
         def get_bucket(bucket_name, options = {})
-          unless bucket_name
-            raise ArgumentError.new('bucket_name is required')
-          end
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
           response = Excon::Response.new
           name = /(\w+\.?)*/.match(bucket_name)
           if bucket_name == name.to_s
-            if bucket = self.data[:buckets][bucket_name]
-              contents = bucket[:objects].values.sort {|x,y| x['Key'] <=> y['Key']}.reject do |object|
-                  (options['prefix'] && object['Key'][0...options['prefix'].length] != options['prefix']) ||
-                  (options['marker'] && object['Key'] <= options['marker'])
-                end.map do |object|
-                  data = object.reject {|key, value| !['ETag', 'Key'].include?(key)}
-                  data.merge!({
-                    'LastModified' => Time.parse(object['Last-Modified']),
-                    'Owner'        => bucket['Owner'],
-                    'Size'         => object['Content-Length'].to_i
-                  })
+            if bucket = data[:buckets][bucket_name]
+              contents = bucket[:objects].values.sort { |x, y| x["Key"] <=> y["Key"] }.reject do |object|
+                (options["prefix"] && object["Key"][0...options["prefix"].length] != options["prefix"]) ||
+                (options["marker"] && object["Key"] <= options["marker"])
+              end.map do |object|
+                data = object.reject { |key, _value| !%w(ETag Key).include?(key) }
+                data.merge!("LastModified" => Time.parse(object["Last-Modified"]),
+                            "Owner"        => bucket["Owner"],
+                            "Size"         => object["Content-Length"].to_i)
                 data
               end
-              max_keys = options['max-keys'] || 1000
+              max_keys = options["max-keys"] || 1000
               size = [max_keys, 1000].min
               truncated_contents = contents[0...size]
 
               response.status = 200
               response.body = {
-                'CommonPrefixes'  => [],
-                'Contents'        => truncated_contents,
-                'IsTruncated'     => truncated_contents.size != contents.size,
-                'Marker'          => options['marker'],
-                'Name'            => bucket['Name'],
-                'Prefix'          => options['prefix']
+                "CommonPrefixes"  => [],
+                "Contents"        => truncated_contents,
+                "IsTruncated"     => truncated_contents.size != contents.size,
+                "Marker"          => options["marker"],
+                "Name"            => bucket["Name"],
+                "Prefix"          => options["prefix"]
               }
-              if options['max-keys'] && options['max-keys'] < response.body['Contents'].length
-                  response.body['IsTruncated'] = true
-                  response.body['Contents'] = response.body['Contents'][0...options['max-keys']]
+              if options["max-keys"] && options["max-keys"] < response.body["Contents"].length
+                response.body["IsTruncated"] = true
+                response.body["Contents"] = response.body["Contents"][0...options["max-keys"]]
               end
             else
               response.status = 404
-              raise(Excon::Errors.status_error({:expects => 200}, response))
+              raise(Excon::Errors.status_error({ :expects => 200 }, response))
             end
           else
-              response.status = 400
-              raise(Excon::Errors.status_error({:expects => 200}, response))
+            response.status = 400
+            raise(Excon::Errors.status_error({ :expects => 200 }, response))
           end
           response
         end

data/lib/fog/storage/google_xml/requests/get_bucket_acl.rb

@@ -0,0 +1,53 @@
+module Fog
+  module Storage
+    class GoogleXML
+      class Real
+        # Get access control list for an Google Storage bucket
+        #
+        # ==== Parameters
+        # * bucket_name<~String> - name of bucket to get access control list for
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'AccessControlPolicy'<~Hash>
+        #       * 'Owner'<~Hash>:
+        #         * 'DisplayName'<~String> - Display name of object owner
+        #         * 'ID'<~String> - Id of object owner
+        #       * 'AccessControlList'<~Array>:
+        #         * 'Grant'<~Hash>:
+        #           * 'Grantee'<~Hash>:
+        #              * 'DisplayName'<~String> - Display name of grantee
+        #              * 'ID'<~String> - Id of grantee
+        #             or
+        #              * 'URI'<~String> - URI of group to grant access for
+        #           * 'Permission'<~String> - Permission, in [FULL_CONTROL, WRITE, WRITE_ACP, READ, READ_ACP]
+        #
+        def get_bucket_acl(bucket_name)
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
+          request(:expects    => 200,
+                  :headers    => {},
+                  :host       => "#{bucket_name}.#{@host}",
+                  :idempotent => true,
+                  :method     => "GET",
+                  :parser     => Fog::Parsers::Storage::Google::AccessControlList.new,
+                  :query      => { "acl" => nil })
+        end
+      end
+
+      class Mock
+        def get_bucket_acl(bucket_name)
+          response = Excon::Response.new
+          if acl = data[:acls][:bucket][bucket_name]
+            response.status = 200
+            response.body = acl
+          else
+            response.status = 404
+            raise(Excon::Errors.status_error({ :expects => 200 }, response))
+          end
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/{google/requests/storage → storage/google_xml/requests}/get_object.rb

@@ -1,6 +1,6 @@
 module Fog
   module Storage
-    class Google
+    class GoogleXML
       class Real
         # Get an object from Google Storage
         #
@@ -24,63 +24,51 @@ module Fog
         #     * 'ETag'<~String> - Etag of object
         #     * 'Last-Modified'<~String> - Last modified timestamp for object
         #
-        def get_object(bucket_name, object_name, options = {}, &block)
-          unless bucket_name
-            raise ArgumentError.new('bucket_name is required')
-          end
-          unless object_name
-            raise ArgumentError.new('object_name is required')
-          end
+        def get_object(bucket_name, object_name, options = {}, &_block)
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
+          raise ArgumentError.new("object_name is required") unless object_name
 
           params = { :headers => {} }
-          if version_id = options.delete('versionId')
-            params[:query] = {'versionId' => version_id}
+          if version_id = options.delete("versionId")
+            params[:query] = { "versionId" => version_id }
           end
           params[:headers].merge!(options)
-          if options['If-Modified-Since']
-            params[:headers]['If-Modified-Since'] = Fog::Time.at(options['If-Modified-Since'].to_i).to_date_header
+          if options["If-Modified-Since"]
+            params[:headers]["If-Modified-Since"] = Fog::Time.at(options["If-Modified-Since"].to_i).to_date_header
           end
-          if options['If-Modified-Since']
-            params[:headers]['If-Unmodified-Since'] = Fog::Time.at(options['If-Unmodified-Since'].to_i).to_date_header
+          if options["If-Modified-Since"]
+            params[:headers]["If-Unmodified-Since"] = Fog::Time.at(options["If-Unmodified-Since"].to_i).to_date_header
           end
 
-          if block_given?
-            params[:response_block] = Proc.new
-          end
+          params[:response_block] = Proc.new if block_given?
 
-          request(params.merge!({
-            :expects        => 200,
-            :host           => "#{bucket_name}.#{@host}",
-            :idempotent     => true,
-            :method         => 'GET',
-            :path           => CGI.escape(object_name),
-          }))
+          request(params.merge!(:expects        => [200, 206],
+                                :host           => "#{bucket_name}.#{@host}",
+                                :idempotent     => true,
+                                :method         => "GET",
+                                :path           => CGI.escape(object_name)))
         end
       end
 
       class Mock
         def get_object(bucket_name, object_name, options = {}, &block)
-          unless bucket_name
-            raise ArgumentError.new('bucket_name is required')
-          end
-          unless object_name
-            raise ArgumentError.new('object_name is required')
-          end
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
+          raise ArgumentError.new("object_name is required") unless object_name
           response = Excon::Response.new
-          if (bucket = self.data[:buckets][bucket_name]) && (object = bucket[:objects][object_name])
-            if options['If-Match'] && options['If-Match'] != object['ETag']
+          if (bucket = data[:buckets][bucket_name]) && (object = bucket[:objects][object_name])
+            if options["If-Match"] && options["If-Match"] != object["ETag"]
               response.status = 412
-            elsif options['If-Modified-Since'] && options['If-Modified-Since'] >= Time.parse(object['Last-Modified'])
+            elsif options["If-Modified-Since"] && options["If-Modified-Since"] >= Time.parse(object["Last-Modified"])
               response.status = 304
-            elsif options['If-None-Match'] && options['If-None-Match'] == object['ETag']
+            elsif options["If-None-Match"] && options["If-None-Match"] == object["ETag"]
               response.status = 304
-            elsif options['If-Unmodified-Since'] && options['If-Unmodified-Since'] < Time.parse(object['Last-Modified'])
+            elsif options["If-Unmodified-Since"] && options["If-Unmodified-Since"] < Time.parse(object["Last-Modified"])
               response.status = 412
             else
               response.status = 200
               for key, value in object
                 case key
-                when 'Cache-Control', 'Content-Disposition', 'Content-Encoding', 'Content-Length', 'Content-MD5', 'Content-Type', 'ETag', 'Expires', 'Last-Modified', /^x-goog-meta-/
+                when "Cache-Control", "Content-Disposition", "Content-Encoding", "Content-Length", "Content-MD5", "Content-Type", "ETag", "Expires", "Last-Modified", /^x-goog-meta-/
                   response.headers[key] = value
                 end
               end
@@ -98,7 +86,7 @@ module Fog
             end
           else
             response.status = 404
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise(Excon::Errors.status_error({ :expects => 200 }, response))
           end
           response
         end

data/lib/fog/{google/requests/storage → storage/google_xml/requests}/get_object_acl.rb

@@ -1,9 +1,7 @@
 module Fog
   module Storage
-    class Google
+    class GoogleXML
       class Real
-        require 'fog/google/parsers/storage/access_control_list'
-
         # Get access control list for an Google Storage object
         #
         # ==== Parameters
@@ -29,38 +27,32 @@ module Fog
         #           * 'Permission'<~String> - Permission, in [FULL_CONTROL, WRITE, WRITE_ACP, READ, READ_ACP]
         #
         def get_object_acl(bucket_name, object_name, options = {})
-          unless bucket_name
-            raise ArgumentError.new('bucket_name is required')
-          end
-          unless object_name
-            raise ArgumentError.new('object_name is required')
-          end
-          query = {'acl' => nil}
-          if version_id = options.delete('versionId')
-            query['versionId'] = version_id
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
+          raise ArgumentError.new("object_name is required") unless object_name
+          query = { "acl" => nil }
+          if version_id = options.delete("versionId")
+            query["versionId"] = version_id
           end
-          request({
-            :expects    => 200,
-            :headers    => {},
-            :host       => "#{bucket_name}.#{@host}",
-            :idempotent => true,
-            :method     => 'GET',
-            :parser     => Fog::Parsers::Storage::Google::AccessControlList.new,
-            :path       => CGI.escape(object_name),
-            :query      => query
-          })
+          request(:expects    => 200,
+                  :headers    => {},
+                  :host       => "#{bucket_name}.#{@host}",
+                  :idempotent => true,
+                  :method     => "GET",
+                  :parser     => Fog::Parsers::Storage::Google::AccessControlList.new,
+                  :path       => CGI.escape(object_name),
+                  :query      => query)
         end
       end
 
       class Mock
         def get_object_acl(bucket_name, object_name)
           response = Excon::Response.new
-          if acl = self.data[:acls][:object][bucket_name] && self.data[:acls][:object][bucket_name][object_name]
+          if acl = data[:acls][:object][bucket_name] && data[:acls][:object][bucket_name][object_name]
             response.status = 200
             response.body = acl
           else
             response.status = 404
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise(Excon::Errors.status_error({ :expects => 200 }, response))
           end
           response
         end

data/lib/fog/{google/requests/storage → storage/google_xml/requests}/get_object_http_url.rb

@@ -1,20 +1,16 @@
 module Fog
   module Storage
-    class Google
+    class GoogleXML
       module GetObjectHttpUrl
         def get_object_http_url(bucket_name, object_name, expires)
-          unless bucket_name
-            raise ArgumentError.new('bucket_name is required')
-          end
-          unless object_name
-            raise ArgumentError.new('object_name is required')
-          end
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
+          raise ArgumentError.new("object_name is required") unless object_name
           http_url({
-            :headers  => {},
-            :host     => @host,
-            :method   => 'GET',
-            :path     => "#{bucket_name}/#{object_name}"
-          }, expires)
+                     :headers  => {},
+                     :host     => @host,
+                     :method   => "GET",
+                     :path     => "#{bucket_name}/#{object_name}"
+                   }, expires)
         end
       end
 

data/lib/fog/{google/requests/storage → storage/google_xml/requests}/get_object_https_url.rb

@@ -1,20 +1,16 @@
 module Fog
   module Storage
-    class Google
+    class GoogleXML
       module GetObjectHttpsUrl
         def get_object_https_url(bucket_name, object_name, expires)
-          unless bucket_name
-            raise ArgumentError.new('bucket_name is required')
-          end
-          unless object_name
-            raise ArgumentError.new('object_name is required')
-          end
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
+          raise ArgumentError.new("object_name is required") unless object_name
           https_url({
-            :headers  => {},
-            :host     => @host,
-            :method   => 'GET',
-            :path     => "#{bucket_name}/#{object_name}"
-          }, expires)
+                      :headers  => {},
+                      :host     => @host,
+                      :method   => "GET",
+                      :path     => "#{bucket_name}/#{object_name}"
+                    }, expires)
         end
       end
 

data/lib/fog/{google/requests/storage → storage/google_xml/requests}/get_object_torrent.rb

@@ -1,6 +1,6 @@
 module Fog
   module Storage
-    class Google
+    class GoogleXML
       class Real
         # Get torrent for an Google Storage object
         #
@@ -23,21 +23,15 @@ module Fog
         #           * 'Permission'<~String> - Permission, in [FULL_CONTROL, WRITE, WRITE_ACP, READ, READ_ACP]
         #
         def get_object_torrent(bucket_name, object_name)
-          unless bucket_name
-            raise ArgumentError.new('bucket_name is required')
-          end
-          unless object_name
-            raise ArgumentError.new('object_name is required')
-          end
-          request({
-            :expects    => 200,
-            :headers    => {},
-            :host       => "#{bucket_name}.#{@host}",
-            :idempotent => true,
-            :method     => 'GET',
-            :path       => CGI.escape(object_name),
-            :query      => {'torrent' => nil}
-          })
+          raise ArgumentError.new("bucket_name is required") unless bucket_name
+          raise ArgumentError.new("object_name is required") unless object_name
+          request(:expects    => 200,
+                  :headers    => {},
+                  :host       => "#{bucket_name}.#{@host}",
+                  :idempotent => true,
+                  :method     => "GET",
+                  :path       => CGI.escape(object_name),
+                  :query      => { "torrent" => nil })
         end
       end
     end