el_finder_s3 0.1.0

data/lib/el_finder_s3/image.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'shellwords'
+require 'image_size'
+
+module ElFinderS3
+
+  # Represents default image handler.
+  # It uses *mogrify* to resize images and *convert* to create thumbnails.
+  class Image
+
+    def self.size(pathname)
+      return nil unless File.exist?(pathname)
+      s = ::ImageSize.new(File.open(pathname)).size.to_s
+      s = nil if s.empty?
+      return s
+    end
+
+    def self.resize(pathname, options = {})
+      return nil unless File.exist?(pathname)
+      system( ::Shellwords.join(['mogrify', '-resize', "#{options[:width]}x#{options[:height]}!", pathname.to_s]) )
+    end # of self.resize
+
+    def self.thumbnail(src, dst, options = {})
+      return nil unless File.exist?(src)
+      system( ::Shellwords.join(['convert', '-resize', "#{options[:width]}x#{options[:height]}", '-background', 'white', '-gravity', 'center', '-extent', "#{options[:width]}x#{options[:height]}", src.to_s, dst.to_s]) )
+    end # of self.resize
+
+  end # of class Image
+
+end # of module ElFinderS3

data/lib/el_finder_s3/mime_type.rb

@@ -0,0 +1,83 @@
+module ElFinderS3
+
+  # Represents default MIME types recognizer.
+  class MimeType
+
+    # File extension to mime type mapping.
+    TYPES = {
+      'ai'    => 'application/postscript',
+      'eps'   => 'application/postscript',
+      'exe'   => 'application/octet-stream',
+      'doc'   => 'application/vnd.ms-word',
+      'xls'   => 'application/vnd.ms-excel',
+      'ppt'   => 'application/vnd.ms-powerpoint',
+      'pps'   => 'application/vnd.ms-powerpoint',
+      'pdf'   => 'application/pdf',
+      'xml'   => 'application/xml',
+      'odt'   => 'application/vnd.oasis.opendocument.text',
+      'swf'   => 'application/x-shockwave-flash',
+      # archives
+      'gz'    => 'application/x-gzip',
+      'tgz'   => 'application/x-gzip',
+      'bz'    => 'application/x-bzip2',
+      'bz2'   => 'application/x-bzip2',
+      'tbz'   => 'application/x-bzip2',
+      'zip'   => 'application/zip',
+      'rar'   => 'application/x-rar',
+      'tar'   => 'application/x-tar',
+      '7z'    => 'application/x-7z-compressed',
+      # texts
+      'txt'   => 'text/plain',
+      'php'   => 'text/x-php',
+      'html'  => 'text/html',
+      'htm'   => 'text/html',
+      'js'    => 'text/javascript',
+      'css'   => 'text/css',
+      'rtf'   => 'text/rtf',
+      'rtfd'  => 'text/rtfd',
+      'py'    => 'text/x-python',
+      'java'  => 'text/x-java-source',
+      'rb'    => 'text/x-ruby',
+      'sh'    => 'text/x-shellscript',
+      'pl'    => 'text/x-perl',
+      'sql'   => 'text/x-sql',
+      # images
+      'bmp'   => 'image/x-ms-bmp',
+      'jpg'   => 'image/jpeg',
+      'jpeg'  => 'image/jpeg',
+      'gif'   => 'image/gif',
+      'png'   => 'image/png',
+      'tif'   => 'image/tiff',
+      'tiff'  => 'image/tiff',
+      'tga'   => 'image/x-targa',
+      'psd'   => 'image/vnd.adobe.photoshop',
+      # audio
+      'mp3'   => 'audio/mpeg',
+      'mid'   => 'audio/midi',
+      'ogg'   => 'audio/ogg',
+      'mp4a'  => 'audio/mp4',
+      'wav'   => 'audio/wav',
+      'wma'   => 'audio/x-ms-wma',
+      # video
+      'avi'   => 'video/x-msvideo',
+      'dv'    => 'video/x-dv',
+      'mp4'   => 'video/mp4',
+      'mpeg'  => 'video/mpeg',
+      'mpg'   => 'video/mpeg',
+      'mov'   => 'video/quicktime',
+      'wm'    => 'video/x-ms-wmv',
+      'flv'   => 'video/x-flv',
+      'mkv'   => 'video/x-matroska'
+    }
+
+    # Gets MIME type fort specified path.
+    # @param [::Pathname, String] pathname Path to recognize its MIME type.
+    # @return [String] MIME type if known; 'unknown/unknown' otherwise.
+    def self.for(pathname)
+      pathname = ::Pathname.new(pathname) if pathname.is_a?(String)
+      TYPES[pathname.extname.downcase[1..-1]] || 'application/octet-stream'
+    end # of for
+
+  end # of class MimeType
+
+end # of module ElFinderS3

data/lib/el_finder_s3/pathname.rb

@@ -0,0 +1,250 @@
+require 'fileutils'
+require 'pathname'
+
+module ElFinderS3
+
+  class Pathname
+    attr_reader :root, :path, :adapter
+
+    #
+    def initialize(adapter_or_root, path = '.')
+      @adapter = adapter_or_root.is_a?(ElFinderS3::Pathname) ? adapter_or_root.adapter : adapter_or_root
+
+      @root = path.is_a?(ElFinderS3::Pathname) ? path.root : S3Pathname.new(@adapter, '/')
+
+      if path.is_a?(ElFinderS3::Pathname)
+        @path = path.path
+      elsif path.is_a?(ElFinderS3::S3Pathname)
+        @path = path
+      else
+        @path = S3Pathname.new(@adapter, path)
+      end
+      if absolute?
+        if @path.cleanpath.to_s.start_with?(@root.to_s)
+          @path = S3Pathname.new(@adapter, @path.to_s.slice((@root.to_s.length)..-1), @path.attrs)
+        elsif @path.cleanpath.to_s.start_with?(@root.realpath.to_s)
+          @path = S3Pathname.new(@adapter, @path.to_s.slice((@root.realpath.to_s.length)..-1), @path.attrs)
+        else
+          raise SecurityError, "Absolute paths are not allowed"
+        end
+      end
+      raise SecurityError, "Paths outside the root are not allowed" if outside_of_root?
+
+    end
+
+    # of initialize
+
+    def type(type)
+      @type = type
+    end
+
+    #
+    def +(other)
+      if other.is_a? ::ElFinderS3::Pathname
+        other = other.path
+      end
+      self.class.new(@adapter, @path + other)
+    end
+
+    # of +
+
+    #
+    def is_root?
+      @path.to_s == '.'
+    end
+
+    #
+    def absolute?
+      @path.absolute?
+    end
+
+    # of absolute?
+
+    #
+    def relative?
+      @path.relative?
+    end
+
+    # of relative?
+
+    #
+    def outside_of_root?
+      !cleanpath.to_s.start_with?(@root.to_s)
+    end
+
+    # of outside_of_root?
+
+    #
+    def fullpath
+      @fullpath ||= (@path.nil? ? @root : @root + @path)
+      b = @path.nil? ? @root : @root + @path
+      return @fullpath
+    end
+
+    # of fullpath
+
+    #
+    def cleanpath
+      fullpath.cleanpath
+    end
+
+    # of cleanpath
+
+    #
+    def realpath
+      fullpath.realpath
+    end
+
+    # of realpath
+
+    #
+    def basename(*args)
+      @path.basename(*args)
+    end
+
+    # of basename
+
+    #
+    def basename_sans_extension
+      @path.basename(@path.extname)
+    end
+
+    # of basename
+
+    #
+    def basename(*args)
+      @path.basename(*args)
+    end
+
+    # of basename
+
+    #
+    def dirname
+      self.class.new(@adapter, @path.dirname)
+    end
+
+    # of basename
+
+    #
+    def extname
+      @path.nil? ? '' : @path.extname
+    end
+
+    # of extname
+
+    #
+    def to_s
+      cleanpath.to_s
+    end
+
+    def to_prefix_s
+      prefix_s = cleanpath.to_s
+      if prefix_s == '/'
+        return ''
+      elsif prefix_s[0] == '/'
+        prefix_s[0] = ''
+      end
+
+      if prefix_s[prefix_s.size-1] != '/'
+        prefix_s = prefix_s + '/'
+      end
+      return prefix_s
+    end
+
+    # of to_s
+    alias_method :to_str, :to_s
+
+    #
+    def child_directories(with_directory=true)
+      adapter.children(self, with_directory).select { |child| child.directory? }.map { |e| self.class.new(@adapter, e) }
+    end
+
+    #
+    def files(with_directory=true)
+      adapter.children(self, with_directory).select { |child| child.file? }.map { |e| self.class.new(@adapter, e) }
+    end
+
+
+    #
+    def children(with_directory=true)
+      adapter.children(self, with_directory).map { |e| self.class.new(@adapter, e) }
+    end
+
+    #
+    def touch(options = {})
+      adapter.touch(cleanpath, options)
+    end
+
+    #
+    def relative_to(other)
+      @path.relative_path_from(other)
+    end
+
+    #
+    def unique
+      return self.dup unless fullpath.file?
+      copy = 1
+      begin
+        new_file = self.class.new(@adapter, dirname + "#{basename_sans_extension} #{copy}#{extname}")
+        copy += 1
+      end while new_file.exist?
+      new_file
+    end
+
+    # of unique
+
+    #
+    def duplicate
+      _basename = basename_sans_extension
+      copy = 1
+      if _basename.to_s =~ /^(.*) copy (\d+)$/
+        _basename = $1
+        copy = $2.to_i
+      end
+      begin
+        new_file = self.class.new(@adapter, dirname + "#{_basename} copy #{copy}#{extname}")
+        copy += 1
+      end while new_file.exist?
+      new_file
+    end
+
+    # of duplicate
+
+    #
+    def rename(to)
+      to = self.class.new(@adapter, to)
+      realpath.rename(to.fullpath.to_s)
+      to
+    end
+
+    # of rename
+
+    {
+      'directory?' => {:path => 'realpath', :rescue => true},
+      'exist?' => {:path => 'realpath', :rescue => true},
+      'file?' => {:path => 'realpath', :rescue => true},
+      'ftype' => {:path => 'realpath', },
+      'mkdir' => {:path => 'fullpath', :args => '(*args)'},
+      'mtime' => {:path => 'realpath', },
+      'open' => {:path => 'fullpath', :args => '(*args, &block)'},
+      'read' => {:path => 'fullpath', :args => '(*args)'},
+      'write' => {:path => 'fullpath', :args => '(*args)'},
+      'readlink' => {:path => 'fullpath', },
+      'readable?' => {:path => 'realpath', :rescue => true},
+      'size' => {:path => 'realpath', },
+      'symlink?' => {:path => 'fullpath', },
+      'unlink' => {:path => 'realpath', },
+      'writable?' => {:path => 'realpath', :rescue => true},
+    }.each_pair do |meth, opts|
+      class_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def #{meth}#{opts[:args]}
+      #{opts[:path]}.#{meth}#{opts[:args]}
+      #{"rescue Errno::ENOENT\nfalse" if opts[:rescue]}
+        end
+      METHOD
+    end
+
+
+  end # of class Pathname
+
+end # of module ElFinderS3

data/lib/el_finder_s3/railties.rb

@@ -0,0 +1,7 @@
+module ElFinderS3
+  class Railties < ::Rails::Railtie
+    initializer 'Rails logger' do
+      ElFinderS3::Connector.logger = Rails.logger
+    end
+  end
+end

data/lib/el_finder_s3/s3_connector.rb

@@ -0,0 +1,89 @@
+require 'aws-sdk'
+
+module ElFinderS3
+  class S3Connector
+    :s3_client
+    :bucket_name
+
+    def initialize(server)
+      Aws.config.update(
+        {
+          region: server[:region],
+          credentials: Aws::Credentials.new(server[:access_key_id], server[:secret_access_key])
+        }
+      )
+      @bucket_name = server[:bucket_name]
+      @s3_client = Aws::S3::Client.new
+    end
+
+    # @param [ElFinderS3::Pathname] pathname
+    def ls_la(pathname, with_directory)
+      prefix = pathname.to_prefix_s
+      query = {
+        bucket: @bucket_name,
+        delimiter: '/',
+        encoding_type: 'url',
+        max_keys: 100,
+        prefix: prefix
+      }
+
+      response = @s3_client.list_objects(query)
+      result = []
+      #Files
+      response.contents.each { |e|
+        if e.key != prefix
+          e.key = e.key.gsub(prefix, '')
+          if with_directory
+            result.push(pathname.fullpath + ::ElFinderS3::S3Pathname.new(self, e))
+          else
+            result.push(::ElFinderS3::S3Pathname.new(self, e))
+          end
+        end
+      }
+      #Folders
+      response.common_prefixes.each { |f|
+        if f.prefix != '' && f.prefix != prefix && f.prefix != '/'
+          f.prefix = f.prefix.split('/').last
+          result.push(pathname.fullpath + ::ElFinderS3::S3Pathname.new(self, f))
+        end
+      }
+      return result
+    end
+
+    # @param [ElFinderS3::Pathname] pathname
+    def exist?(pathname)
+      query = {
+        bucket: @bucket_name,
+        key: pathname.to_prefix_s
+      }
+      begin
+        @s3_client.head_object(query)
+        true
+      rescue Aws::S3::Errors::NotFound
+        false
+      end
+    end
+
+    def mkdir(folder_name)
+      begin
+        @s3_client.put_object(bucket: @bucket_name, key: folder_name)
+        true
+      rescue
+        false
+      end
+    end
+
+    def touch(filename)
+      begin
+        @s3_client.put_object(bucket: @bucket_name, key: filename)
+        true
+      rescue
+        false
+      end
+    end
+
+    def store(filename, content)
+      @s3_client.put_object(bucket: @bucket_name, key: filename, body: content, acl: 'public-read')
+    end
+  end
+end