Forum: Ruby-core [ruby-trunk - Feature #6337][Open] FileUtils#sync

Issue #6337 has been reported by trans (Thomas Sawyer).

----------------------------------------
Feature #6337: FileUtils#sync
https://bugs.ruby-lang.org/issues/6337

Author: trans (Thomas Sawyer)
Status: Open
Priority: Normal
Assignee:
Category: lib
Target version: 1.9.3


=begin
I'd like to see some sort of FileUtils#sync method to sync the contents 
of one directory with another.

Here is a prototype definition:

    #
    # Synchronize a destination directory with a source directory.
    #
    def sync(src, dst, options={})
      src_files = Dir[File.join(src, '**', '*')].map{ |f| f.sub(src+'/', 
'') }
      dst_files = Dir[File.join(dst, '**', '*')].map{ |f| f.sub(dst+'/', 
'') }

      removal = dst_files - src_files

      rm_dirs, rm_files = [], []
      removal.each do |f|
        path = File.join(dst, f)
        if File.directory?(path)
          rm_dirs << path
        else
          rm_files << path
        end
      end

      rm_files.each { |f| rm(f) }
      rm_dirs.each  { |d| rmdir(d) }

      src_files.each do |f|
        src_path = File.join(src, f)
        dst_path = File.join(dst, f)
        if File.directory?(src_path)
          mkdir_p(dst_path)
        else
          parent = File.dirname(dst_path)
          mkdir_p(parent) unless File.directory?(parent)
          install(src_path, dst_path)
        end
      end
    end

I haven't tested this beyond a simple trial. It needs improvement. For 
one, it probably should be able to handle regular files as arguments 
too. It also needs to handle verbose and dryrun options properly. 
Nonetheless, with improvements, would be okay for such to become new 
feature for FileUtils?

=end

Issue #6337 has been updated by mame (Yusuke Endoh).

Status changed from Open to Assigned
Assignee set to matz (Yukihiro Matsumoto)


----------------------------------------
Feature #6337: FileUtils#sync
https://bugs.ruby-lang.org/issues/6337#change-26077

Author: trans (Thomas Sawyer)
Status: Assigned
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: lib
Target version: 1.9.3


=begin
I'd like to see some sort of FileUtils#sync method to sync the contents 
of one directory with another.

Here is a prototype definition:

    #
    # Synchronize a destination directory with a source directory.
    #
    def sync(src, dst, options={})
      src_files = Dir[File.join(src, '**', '*')].map{ |f| f.sub(src+'/', 
'') }
      dst_files = Dir[File.join(dst, '**', '*')].map{ |f| f.sub(dst+'/', 
'') }

      removal = dst_files - src_files

      rm_dirs, rm_files = [], []
      removal.each do |f|
        path = File.join(dst, f)
        if File.directory?(path)
          rm_dirs << path
        else
          rm_files << path
        end
      end

      rm_files.each { |f| rm(f) }
      rm_dirs.each  { |d| rmdir(d) }

      src_files.each do |f|
        src_path = File.join(src, f)
        dst_path = File.join(dst, f)
        if File.directory?(src_path)
          mkdir_p(dst_path)
        else
          parent = File.dirname(dst_path)
          mkdir_p(parent) unless File.directory?(parent)
          install(src_path, dst_path)
        end
      end
    end

I haven't tested this beyond a simple trial. It needs improvement. For 
one, it probably should be able to handle regular files as arguments 
too. It also needs to handle verbose and dryrun options properly. 
Nonetheless, with improvements, would be okay for such to become new 
feature for FileUtils?

=end

Issue #6337 has been updated by bitsweat (Jeremy Kemper).


"Sync" can mean many things. See the long list of options on rsync's man 
page. This makes sense as a separate library that relies on FileUtils. 
It's a complex high-level feature, not a low-level "composable" 
operation like mv or rm.
----------------------------------------
Feature #6337: FileUtils#sync
https://bugs.ruby-lang.org/issues/6337#change-26080

Author: trans (Thomas Sawyer)
Status: Assigned
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: lib
Target version: 1.9.3


=begin
I'd like to see some sort of FileUtils#sync method to sync the contents 
of one directory with another.

Here is a prototype definition:

    #
    # Synchronize a destination directory with a source directory.
    #
    def sync(src, dst, options={})
      src_files = Dir[File.join(src, '**', '*')].map{ |f| f.sub(src+'/', 
'') }
      dst_files = Dir[File.join(dst, '**', '*')].map{ |f| f.sub(dst+'/', 
'') }

      removal = dst_files - src_files

      rm_dirs, rm_files = [], []
      removal.each do |f|
        path = File.join(dst, f)
        if File.directory?(path)
          rm_dirs << path
        else
          rm_files << path
        end
      end

      rm_files.each { |f| rm(f) }
      rm_dirs.each  { |d| rmdir(d) }

      src_files.each do |f|
        src_path = File.join(src, f)
        dst_path = File.join(dst, f)
        if File.directory?(src_path)
          mkdir_p(dst_path)
        else
          parent = File.dirname(dst_path)
          mkdir_p(parent) unless File.directory?(parent)
          install(src_path, dst_path)
        end
      end
    end

I haven't tested this beyond a simple trial. It needs improvement. For 
one, it probably should be able to handle regular files as arguments 
too. It also needs to handle verbose and dryrun options properly. 
Nonetheless, with improvements, would be okay for such to become new 
feature for FileUtils?

=end

"trans (Thomas Sawyer)" <transfire@gmail.com> wrote:
> I'd like to see some sort of FileUtils#sync method to sync the
> contents of one directory with another.

Bad method name.  I thought this was a wrapper for the sync(2)
system call when I saw the topic.

Issue #6337 has been updated by trans (Thomas Sawyer).


Okay, a better name for this method is probably in order. If anyone can 
think of one?

@bitsweet I understand what your saying, but I'm not advocating for an 
implementation of rsync or anything close to it. It's just local fs 
method that should do little more than `install` present files and `rm` 
non-present files. The only option other then `verbose` and `noop` that 
it might support that I can think of is `force`.

----------------------------------------
Feature #6337: FileUtils#sync
https://bugs.ruby-lang.org/issues/6337#change-26081

Author: trans (Thomas Sawyer)
Status: Assigned
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: lib
Target version: 1.9.3


=begin
I'd like to see some sort of FileUtils#sync method to sync the contents 
of one directory with another.

Here is a prototype definition:

    #
    # Synchronize a destination directory with a source directory.
    #
    def sync(src, dst, options={})
      src_files = Dir[File.join(src, '**', '*')].map{ |f| f.sub(src+'/', 
'') }
      dst_files = Dir[File.join(dst, '**', '*')].map{ |f| f.sub(dst+'/', 
'') }

      removal = dst_files - src_files

      rm_dirs, rm_files = [], []
      removal.each do |f|
        path = File.join(dst, f)
        if File.directory?(path)
          rm_dirs << path
        else
          rm_files << path
        end
      end

      rm_files.each { |f| rm(f) }
      rm_dirs.each  { |d| rmdir(d) }

      src_files.each do |f|
        src_path = File.join(src, f)
        dst_path = File.join(dst, f)
        if File.directory?(src_path)
          mkdir_p(dst_path)
        else
          parent = File.dirname(dst_path)
          mkdir_p(parent) unless File.directory?(parent)
          install(src_path, dst_path)
        end
      end
    end

I haven't tested this beyond a simple trial. It needs improvement. For 
one, it probably should be able to handle regular files as arguments 
too. It also needs to handle verbose and dryrun options properly. 
Nonetheless, with improvements, would be okay for such to become new 
feature for FileUtils?

=end

Issue #6337 has been updated by mame (Yusuke Endoh).

Target version changed from 1.9.3 to next minor


----------------------------------------
Feature #6337: FileUtils#sync
https://bugs.ruby-lang.org/issues/6337#change-33790

Author: trans (Thomas Sawyer)
Status: Assigned
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: lib
Target version: next minor


=begin
I'd like to see some sort of FileUtils#sync method to sync the contents 
of one directory with another.

Here is a prototype definition:

    #
    # Synchronize a destination directory with a source directory.
    #
    def sync(src, dst, options={})
      src_files = Dir[File.join(src, '**', '*')].map{ |f| f.sub(src+'/', 
'') }
      dst_files = Dir[File.join(dst, '**', '*')].map{ |f| f.sub(dst+'/', 
'') }

      removal = dst_files - src_files

      rm_dirs, rm_files = [], []
      removal.each do |f|
        path = File.join(dst, f)
        if File.directory?(path)
          rm_dirs << path
        else
          rm_files << path
        end
      end

      rm_files.each { |f| rm(f) }
      rm_dirs.each  { |d| rmdir(d) }

      src_files.each do |f|
        src_path = File.join(src, f)
        dst_path = File.join(dst, f)
        if File.directory?(src_path)
          mkdir_p(dst_path)
        else
          parent = File.dirname(dst_path)
          mkdir_p(parent) unless File.directory?(parent)
          install(src_path, dst_path)
        end
      end
    end

I haven't tested this beyond a simple trial. It needs improvement. For 
one, it probably should be able to handle regular files as arguments 
too. It also needs to handle verbose and dryrun options properly. 
Nonetheless, with improvements, would be okay for such to become new 
feature for FileUtils?

=end