fog-google 0.1.3 → 0.2.0

data/lib/fog/storage/google_xml/models/directories.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Storage
+    class GoogleXML
+      class Directories < Fog::Collection
+        model Fog::Storage::GoogleXML::Directory
+
+        def all
+          data = service.get_service.body["Buckets"]
+          load(data)
+        end
+
+        def get(key, options = {})
+          remap_attributes(options,             :delimiter  => "delimiter",
+                                                :marker     => "marker",
+                                                :max_keys   => "max-keys",
+                                                :prefix     => "prefix")
+          data = service.get_bucket(key, options).body
+          directory = new(:key => data["Name"])
+          options = {}
+          for k, v in data
+            if %w(CommonPrefixes Delimiter IsTruncated Marker MaxKeys Prefix).include?(k)
+              options[k] = v
+            end
+          end
+          directory.files.merge_attributes(options)
+          directory.files.load(data["Contents"])
+          directory
+        rescue Excon::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/{google/models/storage → storage/google_xml/models}/directory.rb

@@ -1,16 +1,13 @@
-require 'fog/core/model'
-require 'fog/google/models/storage/files'
-
 module Fog
   module Storage
-    class Google
+    class GoogleXML
       class Directory < Fog::Model
-        identity  :key,           :aliases => ['Name', 'name']
+        identity :key, :aliases => %w(Name name)
 
-        attribute :creation_date, :aliases => 'CreationDate'
+        attribute :creation_date, :aliases => "CreationDate"
 
         def acl=(new_acl)
-          valid_acls = ['private', 'public-read', 'public-read-write', 'authenticated-read']
+          valid_acls = ["private", "public-read", "public-read-write", "authenticated-read"]
           unless valid_acls.include?(new_acl)
             raise ArgumentError.new("acl must be one of [#{valid_acls.join(', ')}]")
           end
@@ -27,44 +24,39 @@ module Fog
 
         def files
           @files ||= begin
-            Fog::Storage::Google::Files.new(
-              :directory    => self,
-              :service   => service
+            Fog::Storage::GoogleXML::Files.new(
+              :directory => self,
+              :service => service
             )
           end
         end
 
         def public=(new_public)
           if new_public
-            @acl = 'public-read'
+            @acl = "public-read"
           else
-            @acl = 'private'
+            @acl = "private"
           end
           new_public
         end
 
         def public_url
           requires :key
-          if service.get_bucket_acl(key).body['AccessControlList'].find {|entry| entry['Scope']['type'] == 'AllUsers' && entry['Permission'] == 'READ'}
+          if service.get_bucket_acl(key).body["AccessControlList"].detect { |entry| entry["Scope"]["type"] == "AllUsers" && entry["Permission"] == "READ" }
             if key.to_s =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\.(?![\.\-])|\-(?![\.])){1,61}[a-z0-9]$/
               "https://#{key}.storage.googleapis.com"
             else
               "https://storage.googleapis.com/#{key}"
             end
-          else
-            nil
           end
         end
 
         def save
           requires :key
           options = {}
-          if @acl
-            options['x-goog-acl'] = @acl
-          end
-          if @location
-            options['LocationConstraint'] = @location
-          end
+          options["x-goog-acl"] = @acl if @acl
+          options["LocationConstraint"] = @location if @location
+          options["StorageClass"] = attributes[:storage_class] if attributes[:storage_class]
           service.put_bucket(key, options)
           true
         end

data/lib/fog/{google/models/storage → storage/google_xml/models}/file.rb

@@ -1,26 +1,24 @@
-require 'fog/core/model'
-
 module Fog
   module Storage
-    class Google
+    class GoogleXML
       class File < Fog::Model
-        identity  :key,                 :aliases => 'Key'
-
-        attribute :cache_control,       :aliases => 'Cache-Control'
-        attribute :content_disposition, :aliases => 'Content-Disposition'
-        attribute :content_encoding,    :aliases => 'Content-Encoding'
-        attribute :content_length,      :aliases => ['Content-Length', 'Size'], :type => :integer
-        attribute :content_md5,         :aliases => 'Content-MD5'
-        attribute :content_type,        :aliases => 'Content-Type'
-        attribute :etag,                :aliases => ['Etag', 'ETag']
-        attribute :expires,             :aliases => 'Expires'
-        attribute :last_modified,       :aliases => ['Last-Modified', 'LastModified']
+        identity :key, :aliases => "Key"
+
+        attribute :cache_control,       :aliases => "Cache-Control"
+        attribute :content_disposition, :aliases => "Content-Disposition"
+        attribute :content_encoding,    :aliases => "Content-Encoding"
+        attribute :content_length,      :aliases => ["Content-Length", "Size"], :type => :integer
+        attribute :content_md5,         :aliases => "Content-MD5"
+        attribute :content_type,        :aliases => "Content-Type"
+        attribute :etag,                :aliases => %w(Etag ETag)
+        attribute :expires,             :aliases => "Expires"
+        attribute :last_modified,       :aliases => ["Last-Modified", "LastModified"]
         attribute :metadata
-        attribute :owner,               :aliases => 'Owner'
-        attribute :storage_class,       :aliases => ['x-goog-storage-class', 'StorageClass']
+        attribute :owner,               :aliases => "Owner"
+        attribute :storage_class,       :aliases => ["x-goog-storage-class", "StorageClass"]
 
         def acl=(new_acl)
-          valid_acls = ['private', 'public-read', 'public-read-write', 'authenticated-read']
+          valid_acls = ["private", "public-read", "public-read-write", "authenticated-read"]
           unless valid_acls.include?(new_acl)
             raise ArgumentError.new("acl must be one of [#{valid_acls.join(', ')}]")
           end
@@ -28,20 +26,14 @@ module Fog
         end
 
         def body
-          attributes[:body] ||= if last_modified && (file = collection.get(identity))
-            file.body
-          else
-            ''
-          end
+          attributes[:body] ||= last_modified && (file = collection.get(identity)) ? file.body : ""
         end
 
         def body=(new_body)
           attributes[:body] = new_body
         end
 
-        def directory
-          @directory
-        end
+        attr_reader :directory
 
         def copy(target_directory_key, target_file_key)
           requires :directory, :key
@@ -61,7 +53,7 @@ module Fog
 
         remove_method :metadata
         def metadata
-          attributes.reject {|key, value| !(key.to_s =~ /^x-goog-meta-/)}
+          attributes.reject { |key, _value| !(key.to_s =~ /^x-goog-meta-/) }
         end
 
         remove_method :metadata=
@@ -73,17 +65,17 @@ module Fog
         def owner=(new_owner)
           if new_owner
             attributes[:owner] = {
-              :display_name => new_owner['DisplayName'],
-              :id           => new_owner['ID']
+              :display_name => new_owner["DisplayName"],
+              :id           => new_owner["ID"]
             }
           end
         end
 
         def public=(new_public)
           if new_public
-            @acl = 'public-read'
+            @acl = "public-read"
           else
-            @acl = 'private'
+            @acl = "private"
           end
           new_public
         end
@@ -91,9 +83,9 @@ module Fog
         def public_url
           requires :directory, :key
 
-          acl = service.get_object_acl(directory.key, key).body['AccessControlList']
-          access_granted = acl.find do |entry|
-            entry['Scope']['type'] == 'AllUsers' && entry['Permission'] == 'READ'
+          acl = service.get_object_acl(directory.key, key).body["AccessControlList"]
+          access_granted = acl.detect do |entry|
+            entry["Scope"]["type"] == "AllUsers" && entry["Permission"] == "READ"
           end
 
           if access_granted
@@ -102,8 +94,6 @@ module Fog
             else
               "https://storage.googleapis.com/#{directory.key}/#{key}"
             end
-          else
-            nil
           end
         end
 
@@ -112,17 +102,17 @@ module Fog
           if options != {}
             Fog::Logger.deprecation("options param is deprecated, use acl= instead [light_black](#{caller.first})[/]")
           end
-          options['x-goog-acl'] ||= @acl if @acl
-          options['Cache-Control'] = cache_control if cache_control
-          options['Content-Disposition'] = content_disposition if content_disposition
-          options['Content-Encoding'] = content_encoding if content_encoding
-          options['Content-MD5'] = content_md5 if content_md5
-          options['Content-Type'] = content_type if content_type
-          options['Expires'] = expires if expires
+          options["x-goog-acl"] ||= @acl if @acl
+          options["Cache-Control"] = cache_control if cache_control
+          options["Content-Disposition"] = content_disposition if content_disposition
+          options["Content-Encoding"] = content_encoding if content_encoding
+          options["Content-MD5"] = content_md5 if content_md5
+          options["Content-Type"] = content_type if content_type
+          options["Expires"] = expires if expires
           options.merge!(metadata)
 
           data = service.put_object(directory.key, key, body, options)
-          merge_attributes(data.headers.reject {|key, value| ['Content-Length', 'Content-Type'].include?(key)})
+          merge_attributes(data.headers.reject { |key, _value| ["Content-Length", "Content-Type"].include?(key) })
           self.content_length = Fog::Storage.get_body_size(body)
           self.content_type ||= Fog::Storage.get_content_type(body)
           true
@@ -135,9 +125,7 @@ module Fog
 
         private
 
-        def directory=(new_directory)
-          @directory = new_directory
-        end
+        attr_writer :directory
       end
     end
   end

data/lib/fog/{google/models/storage → storage/google_xml/models}/files.rb

@@ -1,32 +1,29 @@
-require 'fog/core/collection'
-require 'fog/google/models/storage/file'
-
 module Fog
   module Storage
-    class Google
+    class GoogleXML
       class Files < Fog::Collection
         extend Fog::Deprecation
         deprecate :get_url, :get_https_url
 
-        attribute :common_prefixes, :aliases => 'CommonPrefixes'
-        attribute :delimiter,       :aliases => 'Delimiter'
+        attribute :common_prefixes, :aliases => "CommonPrefixes"
+        attribute :delimiter,       :aliases => "Delimiter"
         attribute :directory
-        attribute :is_truncated,    :aliases => 'IsTruncated'
-        attribute :marker,          :aliases => 'Marker'
-        attribute :max_keys,        :aliases => ['MaxKeys', 'max-keys']
-        attribute :prefix,          :aliases => 'Prefix'
+        attribute :is_truncated,    :aliases => "IsTruncated"
+        attribute :marker,          :aliases => "Marker"
+        attribute :max_keys,        :aliases => ["MaxKeys", "max-keys"]
+        attribute :prefix,          :aliases => "Prefix"
 
-        model Fog::Storage::Google::File
+        model Fog::Storage::GoogleXML::File
 
         def all(options = {})
           requires :directory
           options = {
-            'delimiter'   => delimiter,
-            'marker'      => marker,
-            'max-keys'    => max_keys,
-            'prefix'      => prefix
+            "delimiter"   => delimiter,
+            "marker"      => marker,
+            "max-keys"    => max_keys,
+            "prefix"      => prefix
           }.merge!(options)
-          options = options.reject {|key,value| value.nil? || value.to_s.empty?}
+          options = options.reject { |_key, value| value.nil? || value.to_s.empty? }
           merge_attributes(options)
           parent = directory.collection.get(
             directory.key,
@@ -34,9 +31,7 @@ module Fog
           )
           if parent
             merge_attributes(parent.files.attributes)
-            load(parent.files.map {|file| file.attributes})
-          else
-            nil
+            load(parent.files.map(&:attributes))
           end
         end
 
@@ -47,10 +42,10 @@ module Fog
           else
             subset = dup.all
 
-            subset.each_file_this_page {|f| yield f}
+            subset.each_file_this_page { |f| yield f }
             while subset.is_truncated
               subset = subset.all(:marker => subset.last.key)
-              subset.each_file_this_page {|f| yield f}
+              subset.each_file_this_page { |f| yield f }
             end
 
             self
@@ -61,13 +56,11 @@ module Fog
           requires :directory
           data = service.get_object(directory.key, key, options, &block)
           file_data = {}
-          data.headers.each do |key, value|
-            file_data[key] = value
+          data.headers.each do |k, v|
+            file_data[k] = v
           end
-          file_data.merge!({
-            :body => data.body,
-            :key  => key
-          })
+          file_data.merge!(:body => data.body,
+                           :key  => key)
           new(file_data)
         rescue Excon::Errors::NotFound
           nil
@@ -86,9 +79,7 @@ module Fog
         def head(key, options = {})
           requires :directory
           data = service.head_object(directory.key, key, options)
-          file_data = data.headers.merge({
-            :key => key
-          })
+          file_data = data.headers.merge(:key => key)
           new(file_data)
         rescue Excon::Errors::NotFound
           nil

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

@@ -1,9 +1,7 @@
 module Fog
   module Storage
-    class Google
+    class GoogleXML
       class Real
-        require 'fog/google/parsers/storage/copy_object'
-
         # Copy an object from one Google Storage bucket to another
         #
         # ==== Parameters
@@ -25,39 +23,35 @@ module Fog
         #     * 'LastModified'<~Time> - date object was last modified
         #
         def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, options = {})
-          headers = { 'x-goog-copy-source' => "/#{source_bucket_name}/#{source_object_name}" }.merge(options)
-          request({
-            :expects  => 200,
-            :headers  => headers,
-            :host     => "#{target_bucket_name}.#{@host}",
-            :method   => 'PUT',
-            :parser   => Fog::Parsers::Storage::Google::CopyObject.new,
-            :path     => Fog::Google.escape(target_object_name)
-          })
+          headers = { "x-goog-copy-source" => "/#{source_bucket_name}/#{source_object_name}" }.merge(options)
+          request(:expects  => 200,
+                  :headers  => headers,
+                  :host     => "#{target_bucket_name}.#{@host}",
+                  :method   => "PUT",
+                  :parser   => Fog::Parsers::Storage::Google::CopyObject.new,
+                  :path     => Fog::Google.escape(target_object_name))
         end
       end
 
       class Mock
-        def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, options = {})
+        def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, _options = {})
           response = Excon::Response.new
-          source_bucket = self.data[:buckets][source_bucket_name]
+          source_bucket = data[:buckets][source_bucket_name]
           source_object = source_bucket && source_bucket[:objects][source_object_name]
-          target_bucket = self.data[:buckets][target_bucket_name]
+          target_bucket = data[:buckets][target_bucket_name]
 
           if source_object && target_bucket
             response.status = 200
             target_object = source_object.dup
-            target_object.merge!({
-              'Name' => target_object_name
-            })
+            target_object.merge!("Name" => target_object_name)
             target_bucket[:objects][target_object_name] = target_object
             response.body = {
-              'ETag'          => target_object['ETag'],
-              'LastModified'  => Time.parse(target_object['Last-Modified'])
+              "ETag"          => target_object["ETag"],
+              "LastModified"  => Time.parse(target_object["Last-Modified"])
             }
           else
             response.status = 404
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise(Excon::Errors.status_error({ :expects => 200 }, response))
           end
 
           response

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

@@ -1,6 +1,6 @@
 module Fog
   module Storage
-    class Google
+    class GoogleXML
       class Real
         # Delete an Google Storage bucket
         #
@@ -11,26 +11,24 @@ module Fog
         # * response<~Excon::Response>:
         #   * status<~Integer> - 204
         def delete_bucket(bucket_name)
-          request({
-            :expects  => 204,
-            :headers  => {},
-            :host     => "#{bucket_name}.#{@host}",
-            :method   => 'DELETE'
-          })
+          request(:expects  => 204,
+                  :headers  => {},
+                  :host     => "#{bucket_name}.#{@host}",
+                  :method   => "DELETE")
         end
       end
 
       class Mock
         def delete_bucket(bucket_name)
           response = Excon::Response.new
-          if self.data[:buckets][bucket_name].nil?
+          if data[:buckets][bucket_name].nil?
             response.status = 404
-            raise(Excon::Errors.status_error({:expects => 204}, response))
-          elsif self.data[:buckets][bucket_name] && !self.data[:buckets][bucket_name][:objects].empty?
+            raise(Excon::Errors.status_error({ :expects => 204 }, response))
+          elsif data[:buckets][bucket_name] && !data[:buckets][bucket_name][:objects].empty?
             response.status = 409
-            raise(Excon::Errors.status_error({:expects => 204}, response))
+            raise(Excon::Errors.status_error({ :expects => 204 }, response))
           else
-            self.data[:buckets].delete(bucket_name)
+            data[:buckets].delete(bucket_name)
             response.status = 204
           end
           response