el_finder 1.0.6 → 1.0.7

data/lib/el_finder/connector.rb

@@ -63,12 +63,12 @@ module ElFinder
 
     #
     def to_hash(pathname)
-      Base64.encode64(pathname == @root ? '/' : pathname.relative_path_from(@root).to_s).chomp
+      Base64.encode64(pathname.path.to_s).chomp
     end # of to_hash
 
     #
     def from_hash(hash)
-      pathname = ElFinder::Pathname.new_with_root(@root, Base64.decode64(hash))
+      pathname = @root + Base64.decode64(hash)
     end # of from_hash
 
     #
@@ -154,7 +154,7 @@ module ElFinder
       end
 
       file = @current + @params[:name]
-      if !file.exist? && FileUtils.touch(file)
+      if !file.exist? && file.touch
         @response[:select] = [to_hash(file)]
         _open(@current)
       else
@@ -199,7 +199,7 @@ module ElFinder
       select = []
       @params[:upload].to_a.each do |file|
         dst = @current + @options[:original_filename_method].call(file)
-        FileUtils.mv(file.path, dst)
+        FileUtils.mv(file.path, dst.fullpath)
         select << to_hash(dst)
       end
       @response[:select] = select
@@ -227,15 +227,15 @@ module ElFinder
           dst = from_hash(@params[:dst]) + src.basename
           if dst.exist?
             @response[:error] ||= 'Some files were unable to be copied'
-            @response[:errorData][src.basename.to_s] = "already exists in '#{dst.dirname.relative_path_from(@root)}'"
+            @response[:errorData][src.basename.to_s] = "already exists in '#{dst.dirname}'"
           else
             if @params[:cut].to_i > 0
               src.rename(dst)
             else
               if src.directory?
-                FileUtils.cp_r(src, dst)
+                FileUtils.cp_r(src.fullpath, dst.fullpath)
               else
-                FileUtils.copy(src, dst)
+                FileUtils.cp(src.fullpath, dst.fullpath)
               end
             end
           end
@@ -273,9 +273,9 @@ module ElFinder
 
       duplicate = @target.duplicate
       if @target.directory?
-        FileUtils.cp_r(@target, duplicate)
+        FileUtils.cp_r(@target, duplicate.fullpath)
       else
-        FileUtils.copy(@target, duplicate)
+        FileUtils.copy(@target, duplicate.fullpath)
       end
       @response[:select] = [to_hash(duplicate)]
       _open(@current)
@@ -321,8 +321,8 @@ module ElFinder
       @response[:error] = 'Access Denied' and return unless !@targets.nil? && @targets.all?{|e| perms_for(e)[:read]} && perms_for(@current)[:write] == true
       @response[:error] = 'No archiver available for this file type' and return if (archiver = @options[:archivers][@params[:type]]).nil?
       extension = archiver.shift
-      basename = @params[:name] || @targets.first.basename_without_extension
-      archive = ElFinder::Pathname.new_with_root(@root, "#{basename}#{extension}").unique
+      basename = @params[:name] || @targets.first.basename_sans_extension
+      archive = (@root + "#{basename}#{extension}").unique
       cmd = ['cd', @current.to_s.shellescape, '&&', archiver.map(&:shellescape), archive.to_s.shellescape, @targets.map{|t| t.basename.to_s.shellescape}].flatten.join(' ')
       if system(cmd)
         @response[:select] = [to_hash(archive)]
@@ -401,7 +401,7 @@ module ElFinder
         :name => pathname.basename.to_s,
         :hash => to_hash(pathname),
         :mime => 'directory',
-        :rel => (@options[:home] + '/' + pathname.relative_path_from(@root).to_s),
+        :rel => pathname.is_root? ? @options[:home] : (@options[:home] + '/' + pathname.path.to_s),
         :size => 0,
         :date => pathname.mtime.to_s,
       }.merge(perms_for(pathname))
@@ -424,7 +424,7 @@ module ElFinder
         response.merge!(
           :size => pathname.size, 
           :mime => mime_handler.for(pathname),
-          :url => (@options[:url] + '/' + pathname.relative_path_from(@root).to_s)
+          :url => (@options[:url] + '/' + pathname.path.to_s)
         )
 
         if pathname.readable? && response[:mime] =~ /image/ && !image_size_handler.nil? && !image_resize_handler.nil?
@@ -438,9 +438,9 @@ module ElFinder
 
       if pathname.symlink?
         response.merge!(
-          :link => to_hash(ElFinder::Pathname.new_with_root(@root, pathname.readlink)), # hash of file to which point link
-          :linkTo => ElFinder::Pathname.new_with_root(@root, pathname.readlink).relative_path_from(pathname.dirname).to_s, # relative path to
-          :parent => to_hash(ElFinder::Pathname.new_with_root(@root, pathname.readlink.dirname)) # hash of directory in which is linked file 
+          :link => to_hash(@root + pathname.readlink), # hash of file to which point link
+          :linkTo => (@root + pathname.readlink).relative_to(pathname.dirname.path).to_s, # relative path to
+          :parent => to_hash((@root + pathname.readlink).dirname) # hash of directory in which is linked file 
         )
       end
 
@@ -470,7 +470,7 @@ module ElFinder
       response[:write] &&= specific_perm_for(pathname, :write) 
       response[:write] &&= @options[:default_perms][:write]
 
-      response[:rm] = pathname != @root 
+      response[:rm] = !pathname.is_root?
       response[:rm] &&= specific_perm_for(pathname, :rm)
       response[:rm] &&= @options[:default_perms][:rm]
 
@@ -479,7 +479,8 @@ module ElFinder
 
     #
     def specific_perm_for(pathname, perm)
-      @options[:perms].select{ |k,v| pathname.relative_path_from(@root).to_s.send((k.is_a?(String) ? :== : :match), k) }.none?{|e| e.last[perm] == false}
+      pathname = pathname.path if pathname.is_a?(ElFinder::Pathname)
+      @options[:perms].select{ |k,v| pathname.to_s.send((k.is_a?(String) ? :== : :match), k) }.none?{|e| e.last[perm] == false}
     end # of specific_perm_for
     
     #

data/lib/el_finder/pathname.rb

@@ -3,75 +3,179 @@ require 'pathname'
 
 module ElFinder
 
-  class Pathname < ::Pathname
+  class Pathname
+    attr_reader :root, :path
 
+    #
+    def initialize(root, path = '.')
+      @root = root.is_a?(ElFinder::Pathname) ? root.root : ::Pathname.new(root)
+
+      @path = ::Pathname.new(path) 
+      @path = path.is_a?(ElFinder::Pathname) ? path.path : ::Pathname.new(path)
+      if absolute?
+        if @path.cleanpath.to_s.start_with?(@root.to_s)
+          @path = ::Pathname.new @path.to_s.slice((@root.to_s.length + 1)..-1)
+        elsif @path.cleanpath.to_s.start_with?(@root.realpath.to_s)
+          @path = ::Pathname.new @path.to_s.slice((@root.realpath.to_s.length + 1)..-1)
+        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 +(other)
-      self.class.new(super(other).to_s)
-    end
+      if other.is_a? ::ElFinder::Pathname
+        other = other.path
+      end
+      self.class.new(@root, (@path + other).to_s)
+    end # of +
 
     #
-    def join(*args)
-      self.class.new(super(*args).to_s)
+    def is_root?
+      @path.to_s == '.'
     end
 
     #
-    def rename(to)
-      super(to)
-    rescue Errno::EXDEV
-      FileUtils.move(self.to_s, to.to_s)
-      @path = to.to_s
-    end # of rename
+    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
+      @path.nil? ? @root : @root + @path
+    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(@root, @path.dirname)
+    end # of basename
+
+    #
+    def extname
+      @path.nil? ? '' : @path.extname
+    end # of extname
 
     #
-    def self.new_with_root(root, path = '')
-      path = path.to_s.sub(root, '') if path.to_s[0,1] == '/'
-      new(superclass.new(File.join(root, path)).cleanpath.to_s)
-    end # of self.new_with_root
+    def to_s
+      cleanpath.to_s
+    end # of to_s
+    alias_method :to_str, :to_s
+
+
+    #
+    def children(with_directory=true)
+      realpath.children(with_directory).map{|e| self.class.new(@root, e)}
+    end
 
     #
-    def basename_without_extension
-      basename(extname)
+    def touch(options = {})
+      FileUtils.touch(cleanpath, options)
     end
 
+    #
+    def relative_to(other)
+      @path.relative_path_from(other)
+    end
+    
+    #
+    def unique
+      return self.dup unless self.file?
+      copy = 1
+      begin
+        new_file = self.class.new(@root, dirname + "#{basename_sans_extension} #{copy}#{extname}")
+        copy += 1
+      end while new_file.exist?
+      new_file
+    end # of unique
+
     #
     def duplicate
-      _dirname = dirname
-      _extname = extname
-      _basename = basename(_extname)
-      copy = 0
+      _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(@root, dirname + "#{_basename} copy #{copy}#{extname}")
         copy += 1
-        new_file = self.class.superclass.new(_dirname + "#{_basename} copy #{copy}#{_extname}")
       end while new_file.exist?
       new_file
     end # of duplicate
 
     #
-    def unique
-      return self.dup unless self.file?
-
-      _dirname = dirname
-      _extname = extname
-      _basename = basename(_extname)
-      copy = 0
+    def rename(to)
+      to = self.class.new(@root, to.to_s)
+      realpath.rename(to.fullpath.to_s)
+    rescue Errno::EXDEV
+      FileUtils.move(realpath.to_s, to.fullpath.to_s)
+    ensure
+      @path = to.path
+    end # of rename
 
-      begin
-        copy += 1
-        new_file = self.class.superclass.new(_dirname + "#{_basename} #{copy}#{_extname}")
-      end while new_file.exist?
-      new_file
-    end # of unique
+    {
+      'directory?' => {:path => 'realpath', :rescue => true                             },
+      'exist?'     => {:path => 'realpath', :rescue => true                             },
+      'file?'      => {:path => 'realpath', :rescue => true                             },
+      'ftype'      => {:path => 'realpath',                                             },
+      'mkdir'      => {:path => 'fullpath',                  :args => '(*args)'         },
+      'mkdir'      => {:path => 'fullpath',                  :args => '(*args)'         },
+      'mtime'      => {:path => 'realpath',                                             },
+      'open'       => {:path => 'fullpath',                  :args => '(*args, &block)' },
+      'read'       => {: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
 
-    #
-    def relative_to(pathname)
-      self == pathname ? '' : relative_path_from(pathname).to_s
-    end # of relative_to
 
   end # of class Pathname
 

data/lib/el_finder/version.rb

@@ -1,3 +1,3 @@
 module ElFinder
-  VERSION = '1.0.6'
+  VERSION = '1.0.7'
 end 

data/test/el_finder/test_mime_type.rb

@@ -24,7 +24,7 @@ class TestMimeType < Test::Unit::TestCase
   end
 
   def test_passing_pathname
-    assert_equal 'text/plain', ElFinder::MimeType.for(ElFinder::Pathname.new('README.txt'))
+    assert_equal 'text/plain', ElFinder::MimeType.for(ElFinder::Pathname.new('/tmp', 'README.txt'))
   end
 
 end

data/test/el_finder/test_pathname.rb

@@ -1,6 +1,7 @@
-require "test/unit"
-require "el_finder"
-require "fileutils"
+require 'test/unit'
+require 'el_finder'
+require 'fileutils'
+require 'pp'
 
 class TestPathname < Test::Unit::TestCase
 
@@ -16,64 +17,268 @@ class TestPathname < Test::Unit::TestCase
 
   ################################################################################
 
-  def test_paths_are_always_clean
-    assert_equal File.join(@vroot, 'foo/bar'), ElFinder::Pathname.new_with_root(@vroot, File.join('foo', '..', 'foo', 'bar')).to_s
-    assert_equal @vroot, ElFinder::Pathname.new_with_root(@vroot, '').to_s
-    assert_equal File.join(@vroot, 'foo/bar'), ElFinder::Pathname.new_with_root(@vroot, File.join('/foo', 'bar')).to_s
+  def test_new_fails_without_root
+    assert_raise ArgumentError do
+      ElFinder::Pathname.new()
+    end
+  end
+
+  def test_new_okay_with_root
+    assert_nothing_raised do
+      ElFinder::Pathname.new(@vroot)
+    end
+  end
+
+  def test_new_okay_with_root_and_path
+    assert_nothing_raised do
+      ElFinder::Pathname.new(@vroot, 'foo.txt')
+    end
+  end
+
+  def test_instance_variables_are_set_correctly
+    p = ElFinder::Pathname.new(@vroot, 'foo.txt')
+    assert_equal @vroot, p.root.to_s
+    assert_equal 'foo.txt', p.path.to_s
+  end
+
+  def test_instance_variables_are_set_correctly_with_nil_path
+    p = ElFinder::Pathname.new(@vroot)
+    assert_equal @vroot, p.root.to_s
+    assert_equal '.', p.path.to_s
+  end
+
+  def test_instance_variables_are_kind_of_pathname
+    p = ElFinder::Pathname.new(@vroot, 'foo.txt')
+    assert_kind_of ::Pathname, p.root
+    assert_kind_of ::Pathname, p.path
+  end
+
+  def test_attempt_to_break_out_of_root_using_relative_path
+    assert_raise SecurityError do
+      p = ElFinder::Pathname.new(@vroot, '../foo.txt')
+    end
+  end
+
+  def test_attempt_to_break_out_of_root_using_absolute_path
+    assert_raise SecurityError do
+      p = ElFinder::Pathname.new(@vroot, '/foo.txt')
+    end
+  end
+
+  def test_new_with_full_path_matching_root
+    p = ElFinder::Pathname.new(@vroot, "#{@vroot}/foo.txt")
+    assert_equal 'foo.txt', p.path.to_s
+  end
+
+  def test_new_with_full_path_matching_root_realpath
+    p = ElFinder::Pathname.new(@vroot, "#{Pathname.new(@vroot).realpath.to_s}/foo.txt")
+    assert_equal 'foo.txt', p.path.to_s
+  end
+
+  def test_plus_string
+    p = ElFinder::Pathname.new(@vroot, 'foo')
+    p1 = p + 'bar'
+    assert_equal 'foo/bar', p1.path.to_s
+  end
+
+  def test_plus_pathname
+    p = ElFinder::Pathname.new(@vroot, 'foo')
+    p1 = p + Pathname.new('bar')
+    assert_equal 'foo/bar', p1.path.to_s
   end
 
+  def test_plus_elfinder_pathname
+    p = ElFinder::Pathname.new(@vroot, 'foo')
+    p1 = p + ElFinder::Pathname.new(@vroot, 'bar')
+    assert_equal 'foo/bar', p1.path.to_s
+  end
+
+  def test_fullpath
+    assert_equal "#{@vroot}/one/two/three.txt", ElFinder::Pathname.new(@vroot, 'one/two/three.txt').fullpath.to_s
+  end
+
+  def test_file?
+    assert_equal true, ElFinder::Pathname.new(@vroot, 'README.txt').file?, "README.txt should be a file"
+    assert_equal false, ElFinder::Pathname.new(@vroot, 'INVALID').file?, "INVALID should not be a file"
+    assert_equal false, ElFinder::Pathname.new(@vroot, 'foo').file?, "foo should not be a file (it's a directory)"
+  end
+
+  def test_directory?
+    assert_equal true, ElFinder::Pathname.new(@vroot, 'foo').directory?, "foo should be a directory"
+    assert_equal false, ElFinder::Pathname.new(@vroot, 'README.txt').directory?, "README.txt should not be a directory (it's a file)"
+    assert_equal false, ElFinder::Pathname.new(@vroot, 'INVALID').directory?, "INVALID should not be a directory"
+  end
+
+  def test_exist?
+    assert_equal true, ElFinder::Pathname.new(@vroot, 'foo').exist?, "foo should exist"
+    assert_equal true, ElFinder::Pathname.new(@vroot, 'README.txt').exist?, "README.txt should exist"
+    assert_equal false, ElFinder::Pathname.new(@vroot, 'INVALID').exist?, "INVALID should not exist"
+  end
+
+  def test_symlink?
+    File.symlink(File.join(@vroot, 'README.txt'), File.join(@vroot, 'symlink.txt'))
+    assert_equal true, ElFinder::Pathname.new(@vroot, 'symlink.txt').symlink?, "symlink.txt should be a symlink"
+    assert_equal false, ElFinder::Pathname.new(@vroot, 'README.txt').symlink?, "README.txt should not be a symlink"
+  end
+
+  def test_readable?
+    assert_equal true, ElFinder::Pathname.new(@vroot, 'foo').readable?, "foo should be readable"
+    assert_equal true, ElFinder::Pathname.new(@vroot, 'README.txt').readable?, "README.txt should be readable"
+    assert_equal false, ElFinder::Pathname.new(@vroot, 'INVALID').readable?, "INVALID should not be readable"
+  end
+
+  def test_writable?
+    assert_equal true, ElFinder::Pathname.new(@vroot, 'foo').writable?, "foo should be writable"
+    assert_equal true, ElFinder::Pathname.new(@vroot, 'README.txt').writable?, "README.txt should be writable"
+    assert_equal false, ElFinder::Pathname.new(@vroot, 'INVALID').writable?, "INVALID should not be writable"
+  end
+
+  def test_mtime
+    assert_equal File.new(File.join(@vroot, 'foo')).mtime, ElFinder::Pathname.new(@vroot, 'foo').mtime
+    assert_equal File.new(File.join(@vroot, 'README.txt')).mtime, ElFinder::Pathname.new(@vroot, 'README.txt').mtime
+    assert_raise Errno::ENOENT do
+      ElFinder::Pathname.new(@vroot, 'INVALID').mtime
+    end
+  end
+
+  def test_unlink
+    assert_equal true, ElFinder::Pathname.new(@vroot, 'README.txt').exist?
+    ElFinder::Pathname.new(@vroot, 'README.txt').unlink
+    assert_equal false, ElFinder::Pathname.new(@vroot, 'README.txt').exist?
+    assert_raise Errno::ENOENT do
+      ElFinder::Pathname.new(@vroot, 'INVALID').unlink
+    end
+    assert_raise Errno::ENOTEMPTY do
+      ElFinder::Pathname.new(@vroot, 'foo').unlink
+    end
+  end
+
+  def test_basename
+    assert_equal 'README.txt', ElFinder::Pathname.new(@vroot, 'README.txt').basename.to_s
+    assert_equal 'README', ElFinder::Pathname.new(@vroot, 'README.txt').basename('.txt').to_s
+    assert_equal 'tom.txt', ElFinder::Pathname.new(@vroot, 'foo/tom.txt').basename.to_s
+  end
+
+  def test_basename_sans_extension
+    assert_equal 'README', ElFinder::Pathname.new(@vroot, 'README.txt').basename_sans_extension.to_s
+    assert_equal 'tom', ElFinder::Pathname.new(@vroot, 'foo/tom.txt').basename_sans_extension.to_s
+  end
+
+  def test_dirname
+    assert_equal '.', ElFinder::Pathname.new(@vroot, 'README.txt').dirname.path.to_s
+    assert_equal 'foo', ElFinder::Pathname.new(@vroot, 'foo/tom.txt').dirname.path.to_s
+  end
+
+  def test_to_s
+    assert_equal "#{@vroot}/README.txt", ElFinder::Pathname.new(@vroot, 'README.txt').to_s
+    assert_equal "#{@vroot}/foo/tom.txt", ElFinder::Pathname.new(@vroot, 'foo/tom.txt').to_s
+  end
+
+  def test_children
+    children = ElFinder::Pathname.new(@vroot, 'foo').children
+    assert_equal 4, children.size
+    assert_equal %w[philip sam sandy tom], children.map{|e| e.basename_sans_extension.to_s}.sort
+  end
+
+  def test_mkdir
+    p = ElFinder::Pathname.new(@vroot, 'some-dir')
+    assert_equal false, p.directory?
+    p.mkdir
+    assert_equal true, p.directory?
+  end
+
+  def test_read
+    p = ElFinder::Pathname.new(@vroot, 'foo/philip.txt')
+    assert_equal File.read(File.join(@vroot, 'foo/philip.txt')), p.read
+  end
+
+  def test_touch
+    p = ElFinder::Pathname.new(@vroot, 'newfile')
+    p.touch
+    assert_equal true, p.file?
+  end
+
+  def test_open
+    p = ElFinder::Pathname.new(@vroot, 'newfile')
+    assert_equal false, p.file?
+    p.open('w') {|f| f.puts "new"}
+    assert_equal true, p.file?
+    assert_equal File.read(File.join(@vroot, 'newfile')), p.read
+  end
+
+  def test_unique_on_create
+    file = ElFinder::Pathname.new(@vroot, 'foo.txt')
+    assert_equal 'foo.txt', file.unique.basename.to_s
+  end
+
+  def test_unique_conflict
+    file = ElFinder::Pathname.new(@vroot, 'pjkh.png')
+    assert_equal 'pjkh 1.png', file.unique.basename.to_s
+  end
+
+  def test_unique_conflict_twice
+    ElFinder::Pathname.new(@vroot, 'pjkh 1.png').touch
+    file = ElFinder::Pathname.new(@vroot, 'pjkh.png')
+    assert_equal 'pjkh 2.png', file.unique.basename.to_s
+  end
+
+
   def test_duplication_without_extension
-    assert_equal File.join(@vroot, 'README copy 1'), ElFinder::Pathname.new_with_root(@vroot,'README').duplicate.to_s
+    assert_equal File.join(@vroot, 'README copy 1'), ElFinder::Pathname.new(@vroot,'README').duplicate.fullpath.to_s
   end
 
   def test_2nd_duplication_without_extension
     ::FileUtils.touch(File.join(@vroot, 'README copy 1'))
-    assert_equal File.join(@vroot, 'README copy 2'), ElFinder::Pathname.new_with_root(@vroot,'README').duplicate.to_s
+    assert_equal File.join(@vroot, 'README copy 2'), ElFinder::Pathname.new(@vroot,'README').duplicate.fullpath.to_s
   end
 
   def test_duplication_with_extension
-    assert_equal File.join(@vroot, 'README copy 1.txt'), ElFinder::Pathname.new_with_root(@vroot,'README.txt').duplicate.to_s
+    assert_equal File.join(@vroot, 'README copy 1.txt'), ElFinder::Pathname.new(@vroot,'README.txt').duplicate.fullpath.to_s
   end
 
   def test_2nd_duplication_with_extension
     ::FileUtils.touch(File.join(@vroot, 'README copy 1.txt'))
-    assert_equal File.join(@vroot, 'README copy 2.txt'), ElFinder::Pathname.new_with_root(@vroot,'README.txt').duplicate.to_s
+    assert_equal File.join(@vroot, 'README copy 2.txt'), ElFinder::Pathname.new(@vroot,'README.txt').duplicate.fullpath.to_s
   end
 
   def test_duplication_of_duplication_lookalike
-    assert_equal File.join(@vroot, 'README copy A copy 1.txt'), ElFinder::Pathname.new_with_root(@vroot,'README copy A.txt').duplicate.to_s
+    assert_equal File.join(@vroot, 'README copy A copy 1.txt'), ElFinder::Pathname.new(@vroot,'README copy A.txt').duplicate.fullpath.to_s
   end
 
   def test_duplication_of_duplication_lookalike2
-    assert_equal File.join(@vroot, 'README copy copy 1.txt'), ElFinder::Pathname.new_with_root(@vroot,'README copy.txt').duplicate.to_s
+    assert_equal File.join(@vroot, 'README copy copy 1.txt'), ElFinder::Pathname.new(@vroot,'README copy.txt').duplicate.fullpath.to_s
   end
 
   def test_on_disk_duplication
-    file = ElFinder::Pathname.new_with_root(@vroot, 'README.txt')
-    FileUtils.touch(file)
+    file = ElFinder::Pathname.new(@vroot, 'README.txt')
+    file.touch
     assert_equal true, File.exist?(File.join(@vroot, 'README.txt'))
     duplicate = file.duplicate
-    FileUtils.touch(duplicate)
+    duplicate.touch
     assert_equal true, File.exist?(File.join(@vroot, 'README copy 1.txt'))
   end
 
-  ################################################################################
-
   def test_rename_on_same_filesystem
-    file = ElFinder::Pathname.new_with_root(@vroot, 'old.txt')
-    FileUtils.touch(file)
+    file = ElFinder::Pathname.new(@vroot, 'old.txt')
+    file.touch
     assert_equal true, File.exist?(File.join(@vroot, 'old.txt'))
     file.rename(File.join(@vroot, 'new.txt'))
     assert_equal false, File.exist?(File.join(@vroot, 'old.txt'))
     assert_equal true, File.exist?(File.join(@vroot, 'new.txt'))
+    assert_equal 'new.txt', file.path.to_s
   end
 
   def test_rename_on_different_filesystem
     if File.directory?('/Volumes/MyBook')
-      file = ElFinder::Pathname.new_with_root(@vroot, 'old.txt')
-      FileUtils.touch(file)
+      file = ElFinder::Pathname.new(@vroot, 'old.txt')
+      file.touch
       assert_equal true, File.exist?(File.join(@vroot, 'old.txt'))
-      file.rename('/Volumes/MyBook/elfinder.rename.test.safe.to.delete')
+
+      File.symlink('/Volumes/MyBook', File.join(@vroot, 'mybook'))
+      assert_equal true, File.symlink?(File.join(@vroot, 'mybook'))
+      assert_equal '/Volumes/MyBook', File.readlink(File.join(@vroot, 'mybook'))
+
+      file.rename('mybook/elfinder.rename.test.safe.to.delete')
       assert_equal false, File.exist?(File.join(@vroot, 'old.txt'))
       assert_equal true, File.exist?('/Volumes/MyBook/elfinder.rename.test.safe.to.delete')
       file.unlink
@@ -81,40 +286,4 @@ class TestPathname < Test::Unit::TestCase
     end
   end
 
-  ################################################################################
-
-  def test_basename_without_extension
-    file = ElFinder::Pathname.new_with_root(@vroot, 'foo.txt')
-    assert_respond_to file, :basename_without_extension
-    assert_equal 'foo', file.basename_without_extension.to_s
-  end
-
-  def test_unique_on_create
-    file = ElFinder::Pathname.new_with_root(@vroot, 'foo.txt')
-    assert_equal 'foo.txt', file.unique.basename.to_s
-  end
-
-  def test_unique_conflict
-    file = ElFinder::Pathname.new_with_root(@vroot, 'pjkh.png')
-    assert_equal 'pjkh 1.png', file.unique.basename.to_s
-  end
-
-  def test_unique_conflict_twice
-    FileUtils.touch ElFinder::Pathname.new_with_root(@vroot, 'pjkh 1.png')
-    file = ElFinder::Pathname.new_with_root(@vroot, 'pjkh.png')
-    assert_equal 'pjkh 2.png', file.unique.basename.to_s
-  end
-
-  def test_relative_to_method
-    assert_equal "", ElFinder::Pathname.new_with_root(@vroot).relative_to(::Pathname.new(@vroot)).to_s
-    assert_equal "foo.txt", ElFinder::Pathname.new_with_root(@vroot, 'foo.txt').relative_to(::Pathname.new(@vroot)).to_s
-    assert_equal "foo/bar.txt", ElFinder::Pathname.new_with_root(@vroot, 'foo/bar.txt').relative_to(::Pathname.new(@vroot)).to_s
-  end
-
-  def test_class_type
-    assert_kind_of ElFinder::Pathname, ElFinder::Pathname.new_with_root(@vroot, 'foo')
-    assert_kind_of ElFinder::Pathname, ElFinder::Pathname.new_with_root(@vroot, 'foo') + 'bar'
-    assert_kind_of ElFinder::Pathname, ElFinder::Pathname.new_with_root(@vroot, 'foo').join('bar')
-  end
-
 end

data/test/test_el_finder.rb

@@ -69,6 +69,18 @@ class TestElFinder < Test::Unit::TestCase
     end
   end
 
+  def test_cwd_name_for_root
+    h, r = @elfinder.run(:cmd => 'open', :init => 'true', :target => '')
+    assert r[:cwd][:name], 'Home'
+  end
+
+  def test_cwd_name_for_sub_directory
+    h, r = @elfinder.run(:cmd => 'open', :init => 'true', :target => '')
+    target = r[:cdc].find{|e| e[:name] == 'foo'}
+    h, r = @elfinder.run(:cmd => 'open', :target => target[:hash])
+    assert r[:cwd][:name], 'Home/foo'
+  end
+
   def test_mkdir
     h, r = @elfinder.run(:cmd => 'open', :init => 'true', :target => '')
     h1, r1 = @elfinder.run(:cmd => 'mkdir', :current => r[:cwd][:hash], :name => 'dir1')

data/test/test_el_finder_hash.rb

@@ -7,13 +7,13 @@ class TestElFinder < Test::Unit::TestCase
   ################################################################################
 
   def test_to_hash_method
-    assert_equal Base64.encode64('foo/bar').chomp, @elfinder.to_hash(ElFinder::Pathname.new_with_root(@vroot, 'foo/bar'))
-    assert_equal Base64.encode64('/').chomp, @elfinder.to_hash(ElFinder::Pathname.new_with_root(@vroot))
+    assert_equal Base64.encode64('foo/bar').chomp, @elfinder.to_hash(ElFinder::Pathname.new(@vroot, 'foo/bar'))
+    assert_equal Base64.encode64('.').chomp, @elfinder.to_hash(ElFinder::Pathname.new(@vroot))
   end
 
   def test_from_hash_method
     assert_equal File.join(@vroot, 'foo/bar'), @elfinder.from_hash(Base64.encode64('foo/bar').chomp).to_s
-    assert_equal @vroot, @elfinder.from_hash(Base64.encode64('').chomp).to_s
+    assert_equal @vroot, @elfinder.from_hash(Base64.encode64('.').chomp).to_s
   end
 
 end

data/test/test_el_finder_symlink.rb

@@ -51,8 +51,6 @@ class TestElFinderSymlink < Test::Unit::TestCase
     h, r = @elfinder.run(:cmd => 'open', :target => foo[:hash])
     source = r[:cdc].find{|e| e[:name] == 'tom.txt'}
 
-    pp source
-    pp target
 
     assert_equal source[:hash], target[:link]
     assert_equal 'foo/tom.txt', target[:linkTo]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: el_finder
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 1
   - 0
-  - 6
-  version: 1.0.6
+  - 7
+  version: 1.0.7
 platform: ruby
 authors: 
 - Philip Hallstrom
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-11 00:00:00 -08:00
+date: 2011-01-12 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency