ruby_clone 1.0.0

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruby_clone.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,10 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+notification :off
+
+guard 'rspec', :cli => "--colour" do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Frederico Benevides
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,329 @@
+# **RubyClone** - Simplifying the use of Rsync
+
+**RubyClone** was designed to be simple, easy, clean and a high level script for RSync.
+
+## Installation
+
+Install the gem:
+
+    gem install ruby_clone
+
+Create a file that is named '.ruby_clone' in your home folder and set up a profile.
+**NOTE**: Don't forget to use the dot in the file.
+
+And then execute:
+
+    $ ruby_clone my_profile
+
+You can also specify another path of your **RubyClone** file:
+
+    $ ruby_clone -b /my/ruby_clone_file my_profile
+
+## Usage
+
+### Basic Configuration
+
+To start using it, you'll need to create the following configuration in your **RubyClone** file.
+
+**NOTE**: The folder of from configurations needs to have the last slash. If it doesn't have, it will copy the
+'source_folder' inside the 'destination_folder'. (This behaviour is from RSync)
+
+**NOTE 2**: If your source folder/destination_folder has spaces as "My Source Folder", you need to set up it as
+"My\\ Source\\ Folder" with **two back slashes** for **each space**. Spaces and only one back slash will not work.
+
+
+    profile :my_profile do
+      from "/my/source_folder/"
+      to "/my/destination_folder"
+    end
+
+If you set up this configuration in your $HOME/.ruby_clone, you can run with:
+
+    $ ruby_clone my_profile
+
+If is in another path, run with:
+
+    $ ruby_clone -b /my/backup_file my_profile
+
+**NOTE**: This basic setup doesn't sync deleted files from the source folder. If you want to delete them, you need
+to setup the option 'delete: true'.
+
+### SSH
+
+**RubyClone** offers the option to use SSH in a easy way. You just need to use the option ':ssh' with the 'user@host'.
+Example for SSH that is on source folder.
+
+    profile :my_profile do
+      from "/my/source_folder/", ssh: "user@source_server"
+      to "/my/destination_folder"
+    end
+
+Example for SSH that is on destination folder:
+
+    profile :my_profile do
+      from "/my/source_folder/"
+      to "/my/destination_folder", ssh: "user@destination_server"
+    end
+
+After running one of theses profiles, you just need to type the password.
+
+## Improving your **RubyClone** file
+
+**RubyClone** aims to be simple and be readable for you when you set up it. All the new configurations that you
+can set up was created with this in mind.
+
+Here is all the configuration you can set up and improve your **RubyClone** file.
+
+### Excluding a Pattern - exclude_pattern "pattern"
+
+  If you need to exclude folders or files matching a pattern, use the 'exclude_pattern command.
+  This command can be used in two ways: On the top of **RubyClone** file and/or inside the 'from'.
+  Here a complete example:
+
+    exclude_pattern "top_pattern"
+
+    profile :my_profile1 do
+      from "/my/source_folder/"
+      to "/my/destination_folder"
+    end
+
+    profile :my_profile2 do
+      from "/my/source_folder/" do
+        exclude_pattern "from_pattern"
+      end
+      to "/my/destination_folder"
+    end
+
+  1. 'my_profile1' will exclude only the "top_pattern".
+  2. 'my_profile2' will exclude the "top_pattern" and "from_pattern"
+
+### Including a Pattern - include_pattern "pattern"
+
+  Same as the exclude_pattern. If you need to include folders or files matching a pattern, use the
+  include_pattern command. This command can be use in two ways: On the top of **RubyClone** file and/or
+  inside the 'from' block. Example:
+
+    include_pattern "top_pattern"
+
+    profile :my_profile1 do
+      from "/my/source_folder/"
+      to "/my/destination_folder"
+    end
+
+    profile :my_profile2 do
+      from "/my/source_folder/" do
+        include_pattern "from_pattern"
+      end
+      to "/my/destination_folder"
+    end
+
+  1. 'my_profile1' will include only the "top_pattern".
+  2. 'my_profile2' will include the "top_pattern" and "from_pattern"
+
+  Here an example using exclude_pattern and include_pattern together. In this example, :my_profile will exclude
+  all folders and will sync/include only the 'from_pattern'
+
+    profile :my_profile do
+      from "/my/source_folder/" do
+        exclude_pattern "*"
+        include_pattern "from_pattern"
+      end
+      to "/my/destination_folder"
+    end
+
+### Deleting files
+
+1. Deleting files that don't exist in source_folder but in destination folder - delete: true
+
+  The basic configuration was created to be a secure configuration. So if you really want to delete files/folders
+  in your destination folder that doesn't exist anymore in your source folder, you'll need to set up 'delete: true' in
+  your **RubyClone** file. Below an example how to do it:
+
+    profile :my_profile do
+      from "/my/source_folder/"
+      to "/my/destination_folder", delete: true
+    end
+
+  Now all files that exists in "/my/destination_folder/" but "/my/source_folder" will be deleted. If for some
+  reason you want to keep some files and delete others, just set up the exclude_pattern inside 'from' block.
+
+2. Deleting files that are excluded from source folder to destination folder - delete_excluded: true
+
+  If you decided to exclude files from the syncronization but they still in your destination folder, you can use
+  the 'delete_excluded' to delete this files inside destination folder that are excluded from the source_folder.
+  Example:
+
+    profile :my_profile do
+      from "/my/source_folder/" do
+        exclude_pattern "my_pattern"
+      end
+      to "/my/destination_folder", delete_excluded: true
+    end
+
+  Now all files that are inside destination_folder that have the pattern 'my_pattern' will be deleted.
+
+  **NOTE**: When you use 'delete_excluded :true' you don't need to set up 'delete: true' even the from
+  configuration doesn't have the 'exclude_pattern'
+
+### Backuping files - backup "folder"
+
+1. If you want to save all the files that get **updated** and **deleted**, you need to set up the 'backup'
+   configuration inside the 'to' block. Example:
+
+    profile :my_profile do
+      from "/my/source_folder/"
+      to "/my/destination_folder", delete: true do
+        backup "/my/backup_folder"
+      end
+    end
+
+  Now all the folders/files that get **updated** or **deleted** in the "/my/destination_folder" will be moved to
+  "/my/backup_folder".  The files moved to "/my/destination_folder" will have a default suffix that is a **RubyClone**
+  control key plus the Date with the format: "yyyyMMdd".
+
+  All files that are saved in the "/my/backup_folder" will have a limit of 5 files. So if any file that passed this
+  limit, the old file will be deleted. You can change this limit using the option "limit".
+
+  **NOTE**: The **RubyClone** control key is a special key to use as a control to remove old duplicated files.
+
+2. Changing the suffix of the files inside the backup folder - backup "folder", suffix: "my_suffix"
+
+  If you want to change the Date suffix for the files that you backup, you need to set the 'suffix' as a parameter to 'backup'.
+  Example:
+
+    profile :my_profile do
+      from "/my/source_folder/"
+      to "/my/destination_folder", delete: true do
+        backup "/my/backup_folder", suffix: "my_suffix"
+      end
+    end
+
+  Another example using suffix with the Time class of Ruby to generate the date with timestamp "yyyyMMdd_hhmmss" :
+
+    profile :my_profile do
+      from "/my/source_folder/"
+      to "/my/destination_folder", delete: true do
+        backup "/my/backup_folder", suffix: "_#{Time.now.strftime("%Y%m%d_%H%M%S")}"
+      end
+    end
+
+  **NOTE**: Changing the suffix will not change the **RubyClone** control key. Since this key control how to remove the
+  old duplicated files.
+
+3. Disabling the default suffix - backup "folder", disable_suffix: true
+
+  If for some reason you want to disable the file suffix in the backup folder you can set true for 'default_true'. Doing
+that all the files that are moved to "/my/backup_folder" will have the same name and it will get override by a new file.
+Example:
+
+    profile :my_profile do
+      from "/my/source_folder/"
+      to "/my/destination_folder", delete: true do
+        backup "/my/backup_folder", disable_suffix: true
+      end
+    end
+
+  **NOTE**: This kind of setup will **backup only one file** and nothing more.
+
+4. Changing how many files you want to backup - backup "folder", limit: 10
+
+  **RubyClone** have a default to save 5 files "/my/backup_folder" that have the same name. If you want to change the
+  limit you just need to set up the option limit with the number of files to save.
+  Example:
+
+    profile :my_profile do
+      from "/my/source_folder/"
+      to "/my/destination_folder", delete: true do
+        backup "/my/backup_folder", limit: 20
+      end
+    end
+
+    Now "/my/backup_folder" will save 20 files with the same name.
+
+5. Disabling the limit of files to save. Save unlimited files - backup "folder", limit: :unlimited
+
+  If for some reason you want to backup all files that are **updated** or **deleted** you need to set up the 'limit'
+  option with ':unlimited'
+  Example:
+
+    profile :my_profile do
+      from "/my/source_folder/"
+      to "/my/destination_folder", delete: true do
+        backup "/my/backup_folder", limit: :unlimited
+      end
+    end
+
+  Now all files will be saved, until you change the 'limit' to a specific number to erased all the old files that passed
+  the new limit.
+
+### Disabling the output commands of RSync - config options
+
+1.  **RubyClone** offers the possibility to not show the rsync command generated (show_command) and rsync output
+  (show_output). To use it, you need to set up in the top of your **RubyClone** file the 'config' and the commands you
+  want to disable. Example:
+
+    config show_command: false, show_output: false
+
+    profile :my_profile do
+      from "/my/source_folder/"
+      to "/my/destination_folder"
+    end
+
+  The above config will not show anymore the rsync command and rsync outputs. But errors will keep showing if
+  happen.
+
+2. Overriding the default configuration of Rsync command - config options: 'override_options'
+
+  If you need to override the default configurations for RSync you can set up the "config options: 'my_options'".
+  Example:
+
+    config options: '-Cav --stats'
+
+    profile :my_profile do
+      from "/my/source_folder/"
+      to "/my/destination_folder"
+    end
+
+## Running
+
+**RubyClone** as default will try to read the **RubyClone** file in your home folder: $HOME/.ruby_clone. If you
+need to specify another path of your **RubyClone** file don't forget to add the option -b
+
+    $ ruby_clone -b /my/ruby_clone_file profile
+
+RSync offers the options to dry-run the command and just run the sincronization as a simulation. You can do this
+too with **RubyClone**. Just pass the option '-d' to ruby_clone
+
+    $ ruby_clone -d profile
+
+## More interesting **RubyClone** file
+
+Here a interesting **RubyClone** file that you can improve.
+
+**NOTE**: Don't forget that the folder of from configuration needs to have the last slash. If it doesn't have,
+it will copy the 'source_folder' inside the 'destination_folder. (This behaviour is from RSync)
+
+**NOTE 2**: If your source folder/destination_folder has spaces as "/My Source Folder", you need to set up it as
+"My\\ Source\\ Folder" with **two back slashes** for **each space**. Spaces and only one back slash will not work.
+
+    profile :my_profile do
+      from "/my/source_folder/" do
+        exclude_pattern "pattern"
+      end
+      to "/my/destination_folder", delete_excluded: true do
+        backup "/my/backup"
+      end
+    end
+
+## **WARNINGS**
+
+  Even this script were has been tested many times, you run this script entirely at your own risk.
+  **RubyClone** accepts no responsibility for any damage this script may cause.
+
+## Contributing to **RubyClone**
+
+* Fork, fix, then send me a pull request.
+
+## Copyright
+
+Copyright (c) 2012 Frederico Benevides. See MIT-LICENSE for further details.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/ruby_clone

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'ruby_clone'
+
+extend RubyClone::DSL
+
+options = RubyClone::Options.new(STDOUT)
+options.parse(ARGV)
+
+if !ARGV.empty?
+  load File.expand_path options.configurations[:backup_file]
+
+  rsync = current_rsync
+  rsync.dry_run = options.configurations[:dry_run]
+  run_backup ARGV[0]
+end

data/lib/ruby_clone/backup_utils.rb

@@ -0,0 +1,41 @@
+require 'fileutils'
+require 'find'
+
+module RubyClone
+
+  module BackupUtils
+
+    def self.delete_files(path, ruby_clone_suffix, limit)
+
+      if File.exists?(path)
+        paths = find_files_with_same_name path, ruby_clone_suffix
+        delete_files_reached_the_limit paths, limit
+      end
+    end
+
+    def self.find_files_with_same_name(path, ruby_clone_suffix)
+      paths = {}
+
+      Find.find(path) do |path|
+        path_without_suffix = path.sub(/#{ruby_clone_suffix}.*/, '')
+
+        if FileTest.file? path
+          paths[path_without_suffix] ||= []
+          paths[path_without_suffix] << path
+        end
+      end
+
+      paths
+    end
+
+    def self.delete_files_reached_the_limit(paths, limit)
+      paths.each_value do |files|
+        if files.size > limit
+          files.slice(0, files.size - limit).each do |file|
+            FileUtils.remove_entry file
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_clone/dsl.rb

@@ -0,0 +1,79 @@
+module RubyClone
+
+  module DSL
+
+    lambda {
+
+      rsync = RubyClone::RSync.new(STDOUT)
+      current_object = rsync
+
+      define_method :current_rsync do
+        rsync
+      end
+
+      define_method :rsync_new_instance do
+        rsync = RubyClone::RSync.new(STDOUT)
+        current_object = rsync
+      end
+
+      define_method :run_backup do |profile|
+        rsync.run profile
+      end
+
+      define_method :profile do |name, &block|
+        profile = Profile.new(name)
+        current_object = profile
+
+        if block
+          rsync.profiles = profile
+          called_block = block.call
+
+          raise SyntaxError, 'Empty Profile not allowed' if not called_block
+        else
+          raise SyntaxError, 'Empty Profile not allowed'
+        end
+
+        current_object = rsync
+      end
+
+      define_method :from do |folder, options = {}, &block|
+        from_folder = FromFolder.new(folder, options)
+        current_object = from_folder
+
+        rsync.last_profile.from_folder = from_folder
+
+        block.call if block
+        current_object = rsync
+      end
+
+      define_method :to do |folder, options = {}, &block|
+        to_folder = ToFolder.new(folder, options)
+        current_object = to_folder
+
+        rsync.last_profile.to_folder = to_folder
+
+        block.call if block
+        current_object = rsync
+      end
+
+      define_method :backup do |path, options = {}|
+        backup = Backup.new(path, options)
+        current_object.backup = backup
+      end
+
+      define_method :exclude_pattern do |path|
+        current_object.exclude_pattern = path
+      end
+
+      define_method :include_pattern do |path|
+        current_object.include_pattern = path
+      end
+
+      define_method :config do |configurations|
+        current_object.update_configurations configurations
+      end
+
+    }.call
+
+  end
+end

data/lib/ruby_clone/options.rb

@@ -0,0 +1,38 @@
+require 'optparse'
+
+module RubyClone
+
+  class Options
+    attr_reader :configurations
+    attr_reader :profile
+
+    def initialize(output)
+      @output = output
+      @configurations = {}
+      @configurations[:backup_file] = '~/.ruby_clone'
+    end
+
+    def parse(argv)
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: ruby_clone [options] profile"
+
+        opts.on("-b", "--backup-file path", String, "Change the path to backup file (default is #{ENV['HOME']}/.ruby_clone)") do |backup_file|
+          @configurations[:backup_file] = backup_file
+        end
+
+        opts.on("-d", "--dry-run", "Show what would have been transferred") do
+          @configurations[:dry_run] = true
+        end
+
+        opts.on("-h", "--help", "This message") do
+          @output.puts opts
+        end
+
+        argv = %w[-h] if argv.empty?
+        opts.parse!(argv)
+      end
+      opts
+    end
+
+  end
+end

data/lib/ruby_clone/profile.rb

@@ -0,0 +1,128 @@
+module RubyClone
+
+  class FromFolder
+    attr_accessor :path
+
+    def initialize(path, options = {})
+      @exclude_patterns = []
+      @include_patterns = []
+      @options = options
+      @path = path
+    end
+
+    def exclude_pattern=(path)
+      @exclude_patterns << path
+    end
+
+    def include_pattern=(path)
+      @include_patterns << path
+    end
+
+    def to_command
+      command = ""
+      command << @include_patterns.map { |e| "--include=#{e}" }.join(" ") + " "
+      command << @exclude_patterns.map { |e| "--exclude=#{e}" }.join(" ")
+      command.strip
+    end
+
+    def ssh?
+     if @options[:ssh]
+       true
+     else
+       false
+     end
+    end
+
+    def to_s
+      return "#{@options[:ssh]}:#{@path}" if @options[:ssh]
+      return @path if not @options[:ssh]
+    end
+  end
+
+  class ToFolder
+    attr_accessor :backup
+    attr_accessor :path
+
+    def initialize(path, options = {})
+      @path = path
+      @options = options
+    end
+
+    def delete_files
+      @backup.delete_files if @backup
+    end
+
+    def to_command
+      command = ""
+      command << "--delete " if @options[:delete]
+      command << "--delete-excluded " if @options[:delete_excluded]
+
+      command << backup.to_command if backup
+      command.strip
+    end
+
+    def ssh?
+      if @options[:ssh]
+        true
+      else
+        false
+      end
+    end
+
+    def to_s
+      return "#{@options[:ssh]}:#{@path}" if @options[:ssh]
+      return @path if not @options[:ssh]
+    end
+  end
+
+  class Profile
+    attr_accessor :name
+    attr_accessor :from_folder
+    attr_accessor :to_folder
+
+    def initialize(name)
+      @name = name.to_s
+    end
+
+    def to_s
+      @name
+    end
+  end
+
+  class Backup
+    attr_accessor :path
+
+    def initialize(path, options = { })
+      @default_suffix = '_rbcl'
+      @options = { disable_suffix: false, limit: 5 }.merge(options)
+      @path = path
+
+    end
+
+    def delete_files
+      BackupUtils.delete_files @path, @default_suffix, @options[:limit] if @options[:limit] != :unlimited
+    end
+
+    def to_command
+      command = "-b "
+      command << "#{create_suffix} " if not @options[:disable_suffix]
+      command << "--backup-dir=#{path} "
+      command.strip
+    end
+
+   private
+
+    def create_suffix
+      time = @time || Time.now.strftime("%Y%m%d")
+      command = "--suffix="
+      command << "#{@default_suffix}_#{time}" if not @options[:suffix]
+      command << "#{@default_suffix}#{@options[:suffix]}" if @options[:suffix]
+      command
+    end
+
+    def to_s
+      @path
+    end
+  end
+
+end