phpfog-fog 0.4.1

data/lib/fog/storage/models/aws/files.rb

@@ -0,0 +1,79 @@
+require 'fog/core/collection'
+require 'fog/storage/models/aws/file'
+
+module Fog
+  module AWS
+    class Storage
+
+      class Files < Fog::Collection
+
+        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'
+
+        model Fog::AWS::Storage::File
+
+        def all(options = {})
+          requires :directory
+          options = {
+            'delimiter'   => delimiter,
+            'marker'      => marker,
+            'max-keys'    => max_keys,
+            'prefix'      => prefix
+          }.merge!(options)
+          options = options.reject {|key,value| value.nil? || value.to_s.empty?}
+          merge_attributes(options)
+          parent = directory.collection.get(
+            directory.key,
+            options
+          )
+          if parent
+            merge_attributes(parent.files.attributes)
+            load(parent.files.map {|file| file.attributes})
+          else
+            nil
+          end
+        end
+
+        def get(key, options = {}, &block)
+          requires :directory
+          data = connection.get_object(directory.key, key, options, &block)
+          file_data = data.headers.merge({
+            :body => data.body,
+            :key  => key
+          })
+          new(file_data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+        def get_url(key, expires)
+          requires :directory
+          connection.get_object_url(directory.key, key, expires)
+        end
+
+        def head(key, options = {})
+          requires :directory
+          data = connection.head_object(directory.key, key, options)
+          file_data = data.headers.merge({
+            :key => key
+          })
+          new(file_data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :directory
+          super({ :directory => directory }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'fog/core/collection'
+require 'fog/storage/models/google/directory'
+
+module Fog
+  module Google
+    class Storage
+
+      class Directories < Fog::Collection
+
+        model Fog::Google::Storage::Directory
+
+        def all
+         data = connection.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 = connection.get_bucket(key, options).body
+          directory = new(:key => data['Name'])
+          options = {}
+          for k, v in data
+            if ['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/storage/models/google/directory.rb

@@ -0,0 +1,81 @@
+require 'fog/core/model'
+require 'fog/storage/models/google/files'
+
+module Fog
+  module Google
+    class Storage
+
+      class Directory < Fog::Model
+        extend Fog::Deprecation
+        deprecate(:name, :key)
+        deprecate(:name=, :key=)
+
+        identity  :key,           :aliases => ['Name', 'name']
+
+        attribute :creation_date, :aliases => 'CreationDate'
+
+        def acl=(new_acl)
+          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
+          @acl = new_acl
+        end
+
+        def destroy
+          requires :key
+          connection.delete_bucket(key)
+          true
+        rescue Excon::Errors::NotFound
+          false
+        end
+
+        def files
+          @files ||= begin
+            Fog::Google::Storage::Files.new(
+              :directory    => self,
+              :connection   => connection
+            )
+          end
+        end
+
+        def public=(new_public)
+          if new_public
+            @acl = 'public-read'
+          else
+            @acl = 'private'
+          end
+          new_public
+        end
+
+        def public_url
+          requires :key
+          if connection.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}.commondatastorage.googleapis.com"
+            else
+              "https://commondatastorage.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
+          connection.put_bucket(key, options)
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/storage/models/google/file.rb

@@ -0,0 +1,148 @@
+require 'fog/core/model'
+
+module Fog
+  module Google
+    class Storage
+
+      class File < Fog::Model
+        extend Fog::Deprecation
+        deprecate(:size, :content_length)
+        deprecate(:size=, :content_length=)
+
+        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']
+        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']
+        attribute :metadata
+        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']
+          unless valid_acls.include?(new_acl)
+            raise ArgumentError.new("acl must be one of [#{valid_acls.join(', ')}]")
+          end
+          @acl = new_acl
+        end
+
+        def body
+          attributes[:body] ||= if last_modified && (file = collection.get(identity))
+            file.body
+          else
+            ''
+          end
+        end
+
+        def body=(new_body)
+          attributes[:body] = new_body
+        end
+
+        def directory
+          @directory
+        end
+
+        def copy(target_directory_key, target_file_key)
+          requires :directory, :key
+          connection.copy_object(directory.key, key, target_directory_key, target_file_key)
+          target_directory = connection.directories.new(:key => target_directory_key)
+          target_directory.files.get(target_file_key)
+        end
+
+        def destroy
+          requires :directory, :key
+          begin
+            connection.delete_object(directory.key, key)
+          rescue Excon::Errors::NotFound
+          end
+          true
+        end
+
+        remove_method :metadata
+        def metadata
+          attributes.reject {|key, value| !(key.to_s =~ /^x-goog-meta-/)}
+        end
+
+        remove_method :metadata=
+        def metadata=(new_metadata)
+          merge_attributes(new_metadata)
+        end
+
+        remove_method :owner=
+        def owner=(new_owner)
+          if new_owner
+            attributes[:owner] = {
+              :display_name => new_owner['DisplayName'],
+              :id           => new_owner['ID']
+            }
+          end
+        end
+
+        def public=(new_public)
+          if new_public
+            @acl = 'public-read'
+          else
+            @acl = 'private'
+          end
+          new_public
+        end
+
+        def public_url
+          requires :directory, :key
+          if connection.get_object_acl(directory.key, key).body['AccessControlList'].detect {|entry| entry['Scope']['type'] == 'AllUsers' && entry['Permission'] == 'READ'}
+            if directory.key.to_s =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\.(?![\.\-])|\-(?![\.])){1,61}[a-z0-9]$/
+              "https://#{directory.key}.commondatastorage.googleapis.com/#{key}"
+            else
+              "https://commondatastorage.googleapis.com/#{directory.key}/#{key}"
+            end
+          else
+            nil
+          end
+        end
+
+        def save(options = {})
+          requires :body, :directory, :key
+          if options != {}
+            Formatador.display_line("[yellow][WARN] 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.merge(metadata)
+
+          data = connection.put_object(directory.key, key, body, options)
+          merge_attributes(data.headers)
+          if body.is_a?(String)
+            self.content_length = body.size
+          else
+            self.content_length = ::File.size(body.path)
+          end
+          true
+        end
+
+        def url(expires)
+          requires :key
+          collection.get_url(key, expires)
+        end
+
+        private
+
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/storage/models/google/files.rb

@@ -0,0 +1,79 @@
+require 'fog/core/collection'
+require 'fog/storage/models/google/file'
+
+module Fog
+  module Google
+    class Storage
+
+      class Files < Fog::Collection
+
+        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'
+
+        model Fog::Google::Storage::File
+
+        def all(options = {})
+          requires :directory
+          options = {
+            'delimiter'   => delimiter,
+            'marker'      => marker,
+            'max-keys'    => max_keys,
+            'prefix'      => prefix
+          }.merge!(options)
+          options = options.reject {|key,value| value.nil? || value.to_s.empty?}
+          merge_attributes(options)
+          parent = directory.collection.get(
+            directory.key,
+            options
+          )
+          if parent
+            merge_attributes(parent.files.attributes)
+            load(parent.files.map {|file| file.attributes})
+          else
+            nil
+          end
+        end
+
+        def get(key, options = {}, &block)
+          requires :directory
+          data = connection.get_object(directory.key, key, options, &block)
+          file_data = data.headers.merge({
+            :body => data.body,
+            :key  => key
+          })
+          new(file_data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+        def get_url(key, expires)
+          requires :directory
+          connection.get_object_url(directory.key, key, expires)
+        end
+
+        def head(key, options = {})
+          requires :directory
+          data = connection.head_object(directory.key, key, options)
+          file_data = data.headers.merge({
+            :key => key
+          })
+          new(file_data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :directory
+          super({ :directory => directory }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'fog/core/collection'
+require 'fog/storage/models/local/directory'
+
+module Fog
+  module Local
+    class Storage
+
+      class Directories < Fog::Collection
+
+        model Fog::Local::Storage::Directory
+
+        def all
+          data = Dir.entries(connection.local_root).select do |entry|
+            entry[0...1] != '.' && ::File.directory?(connection.path_to(entry))
+          end.map do |entry|
+            {:key => entry}
+          end
+          load(data)
+        end
+
+        def get(key)
+          if ::File.directory?(connection.path_to(key))
+            new(:key => key)
+          else
+            nil
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/storage/models/local/directory.rb

@@ -0,0 +1,60 @@
+require 'fog/core/model'
+require 'fog/storage/models/local/files'
+
+module Fog
+  module Local
+    class Storage
+
+      class Directory < Fog::Model
+        extend Fog::Deprecation
+        deprecate(:name, :key)
+        deprecate(:name=, :key=)
+
+        identity  :key
+
+        def destroy
+          requires :key
+
+          if ::File.directory?(path)
+            Dir.rmdir(path)
+            true
+          else
+            false
+          end
+        end
+
+        def files
+          @files ||= begin
+            Fog::Local::Storage::Files.new(
+              :directory    => self,
+              :connection   => connection
+            )
+          end
+        end
+
+        def public=(new_public)
+          new_public
+        end
+
+        def public_url
+          nil
+        end
+
+        def save
+          requires :key
+
+          Dir.mkdir(path)
+          true
+        end
+
+        private
+
+        def path
+          connection.path_to(key)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/storage/models/local/file.rb

@@ -0,0 +1,75 @@
+require 'fog/core/model'
+
+module Fog
+  module Local
+    class Storage
+
+      class File < Fog::Model
+
+        identity  :key,             :aliases => 'Key'
+
+        attribute :content_length,  :aliases => 'Content-Length'
+        # attribute :content_type,    :aliases => 'Content-Type'
+        attribute :last_modified,   :aliases => 'Last-Modified'
+
+        def body
+          attributes[:body] ||= if last_modified
+            collection.get(identity).body
+          else
+            ''
+          end
+        end
+
+        def body=(new_body)
+          attributes[:body] = new_body
+        end
+
+        def directory
+          @directory
+        end
+
+        def destroy
+          requires :directory, :key
+          ::File.delete(path)
+          true
+        end
+
+        def public=(new_public)
+          new_public
+        end
+
+        def public_url
+          nil
+        end
+
+        def save(options = {})
+          requires :body, :directory, :key
+          file = ::File.new(path, 'w')
+          if body.is_a?(String)
+            file.write(body)
+          else
+            file.write(body.read)
+          end
+          file.close
+          merge_attributes(
+            :content_length => ::File.size(path),
+            :last_modified  => ::File.mtime(path)
+          )
+          true
+        end
+
+        private
+
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+
+        def path
+          connection.path_to(::File.join(directory.key, CGI.escape(key)))
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/storage/models/local/files.rb

@@ -0,0 +1,84 @@
+require 'fog/core/collection'
+require 'fog/storage/models/local/file'
+
+module Fog
+  module Local
+    class Storage
+
+      class Files < Fog::Collection
+
+        attribute :directory
+
+        model Fog::Local::Storage::File
+
+        def all
+          requires :directory
+          if directory.collection.get(directory.key)
+            data = Dir.entries(connection.path_to(directory.key)).select do |key|
+              key[0...1] != '.' && !::File.directory?(connection.path_to(key))
+            end.map do |key|
+              path = file_path(key)
+              {
+                :content_length => ::File.size(path),
+                :key            => CGI.unescape(key),
+                :last_modified  => ::File.mtime(path)
+              }
+            end
+            load(data)
+          else
+            nil
+          end
+        end
+
+        def get(key, &block)
+          requires :directory
+          path = file_path(CGI.escape(key))
+          if ::File.exists?(path)
+            data = {
+              :content_length => ::File.size(path),
+              :key            => key,
+              :last_modified  => ::File.mtime(path)
+            }
+            if block_given?
+              file = ::File.open(path)
+              while (chunk = file.read(Excon::CHUNK_SIZE)) && yield(chunk); end
+              file.close
+              new(data)
+            else
+              body = ::File.read(path)
+              new(data.merge!(:body => body))
+            end
+          else
+            nil
+          end
+        end
+
+        def head(key)
+          requires :directory
+          path = file_path(CGI.escape(key))
+          if ::File.exists?(path)
+            new({
+              :content_length => ::File.size(path),
+              :key            => key,
+              :last_modified  => ::File.mtime(path)
+            })
+          else
+            nil
+          end
+        end
+
+        def new(attributes = {})
+          requires :directory
+          super({ :directory => directory }.merge!(attributes))
+        end
+
+        private
+
+        def file_path(key)
+          connection.path_to(::File.join(directory.key, key))
+        end
+
+      end
+    end
+  end
+end