raz 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cba3b8783105105a189f73b386f5423d4d9caf02
+  data.tar.gz: 9e7e5e1d8d571359eaf8bbd01fcdb208b1dc2d5b
+SHA512:
+  metadata.gz: 53214d6e8ecffa2a2837bf516aa370ceb74a3a6fa5e8c9e5eb15951d7a18d60ba67d93745c0eb2e8525d6fc09a0c501227716c15080a73c57ae943495d103dc3
+  data.tar.gz: 1f63bae43ca5203167fba5b8ae74b3ace9f9ce976ac9dc0417f269023007a7a7eb3a41822924e16ab13a60f2e7f8e9fb535c1470d26f354d095757113bbd0019

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Roman Kříž
+
+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,57 @@
+# Raz
+
+[![Build Status](https://travis-ci.org/samnung/raz.svg)](https://travis-ci.org/samnung/raz)
+
+Raz is simple tool to backup all files to some external hard drive and restoring with only four commands.
+
+```bash
+sudo gem install raz
+raz backup /Volumes/Fry/Backup-2015-07-22
+
+# ... and on another machine
+sudo gem install raz
+raz restore /Volumes/Fry/Backup-2015-07-22
+```
+
+Raz is designed to work on OS X and theoretically should work on Linux too.
+
+
+## Motivation
+
+I hate [mackup](https://github.com/lra/mackup) because of creating links to Dropbox or any other place and I am not big fan of Python.
+
+I hate [Time Machine](https://en.wikipedia.org/wiki/Time_Machine_(OS_X)) because of backing up all files instead of specific ones (so when you want to reinstall to resolve some problems it doesn't work).
+
+So I've created simple tool but with possibility to be powerfull in near future.
+
+
+## Configuration file
+
+Core of this tool is text file containing all files and directories should be backed up. There is no magic YAML, JSON, Config files with strange structure. Files uses Ruby syntax to define applications, their preferences and other valuable files. File must be located in home folder, exactly `~/.raz/config.rb`. Here is simple example of this tool can do:
+
+```ruby
+group 'Dot files' do
+    path '~/.zprofile'
+    path '~/.zshrc'
+    # ...
+    path '~/.git*' # everything starting with '.git' in home folder
+end
+
+app 'Sublime Text 3' do
+  path '~/Library/Application Support/Sublime Text 3/'
+  # ...
+end
+
+app 'Xcode' do
+    path '~/Library/Developer/Xcode/UserData/CodeSnippets/'
+    path '~/Library/Developer/Xcode/UserData/FontAndColorThemes/'
+    # ...
+end
+```
+
+`group` and `app` is same for now. Both supports adding path to files or folders to be backed up. You can also use wildcard expressions same as [`Dir.glob`](http://ruby-doc.org/core-2.2.0/Dir.html#method-c-glob) supports.
+
+
+## License
+
+The tool is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/bin/raz

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path('../lib', File.dirname(__FILE__))
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'raz'
+require 'gli'
+
+include GLI::App
+
+program_desc 'Tool to backup and restore files.'
+
+
+on_error do |e|
+  $stderr.puts "#{e.message}".red
+  $stderr.puts "#{e.backtrace_locations.join("\n")}".red
+end
+
+
+# ----------------------- backup -----------------------------------
+
+desc 'Backup all files to destination folder'
+arg :destination_path
+
+command :backup do |c|
+  # c.desc 'Path to configuration file'
+  # c.flag :c, :conf
+
+  c.action do |global_options, options, args|
+    help_now! 'Specify at least one destination path' if args.size == 0
+    help_now! 'Specify only one destination path' if args.size > 1
+
+    config_path = Raz::config_path
+    help_now! "Missing configuration file at #{Raz::config_path}" unless File.file?(config_path)
+
+    backuper = Raz::Backuper.new(Raz::ConfigFile.new(config_path), args.first)
+    backuper.backup
+  end
+end
+
+
+
+
+# ----------------------- restore -----------------------------------
+
+desc 'Restore all files from source folder'
+arg :source_path
+
+command :restore do |c|
+  c.action do |global_options, options, args|
+    help_now! 'Specify at least one source path' if args.size == 0
+    help_now! 'Specify only one source path' if args.size > 1
+
+    restorer = Raz::Restorer.new(args.first)
+    restorer.restore
+  end
+end
+
+
+
+# ---------------------------------------------------------
+
+exit run(ARGV)

data/lib/raz/backuper.rb

@@ -0,0 +1,208 @@
+
+require 'yaml'
+require 'colorize'
+require_relative 'file_operations'
+require_relative 'entries'
+
+
+module Raz
+  class Backuper
+    # @return [String]
+    #
+    attr_reader :destination_path
+
+    # @return [Array<DirEntry | FileEntry>]
+    #
+    attr_reader :parsed_entries
+
+    # @param [Config] config
+    #
+    def initialize(config, destination_path)
+      @config = config
+      @destination_path = File.expand_path(destination_path)
+    end
+
+    def investigate
+      @file_system = FileSystem.new
+      @parsed_entries = []
+
+      # process all items from configuration file
+      @config.items.each do |item|
+        process_item(item)
+      end
+    end
+
+    # Main method to back all files from configuration
+    #
+    def backup
+      FileUtils.mkdir_p(@destination_path)
+
+      dest_contents = FileOperations.dir_entries(@destination_path)
+
+      unless dest_contents.empty?
+        raise "Can only operate on empty or non-existing directory! Directory #{@destination_path} contains: #{dest_contents}"
+      end
+
+      # run before procs
+      (@config.procs[:before_backup] || []).each do |proc|
+        instance_eval &proc
+      end
+
+      investigate if @parsed_entries.nil?
+
+      @copied_paths = []
+
+      @parsed_entries.each do |entry|
+        copy_entry_to_dest(entry)
+      end
+
+      # save info for restorer
+      save_info
+
+      # backup config folder
+      FileOperations.copy_item(File.dirname(@config.path), @destination_path)
+      FileUtils.mv(File.join(@destination_path, CONFIG_FOLDER_BASE_PATH), File.join(@destination_path, BACKUP_CONFIG_FOLDER_BASE_PATH))
+
+      # run after procs
+      (@config.procs[:after_backup] || []).each do |proc|
+        instance_eval &proc
+      end
+    end
+
+    private
+
+    # @param item [Raz::Items::Group] item to process
+    #
+    def process_item(item)
+      @current_item = item
+      @ignored_items = (@config.ignored_paths + @current_item.ignored_paths).map { |p| File.expand_path(p) }
+
+      puts "Processing group #{item.name}"
+
+      item.paths.each do |requirement_path|
+        print "  Processing requirement path #{requirement_path} ... "
+
+        abs_path = File.expand_path(requirement_path)
+
+        if File.directory?(abs_path)
+          process_directory(abs_path)
+          puts 'Success'.green
+        elsif File.file?(abs_path)
+          process_file(abs_path)
+          puts 'Success'.green
+        elsif %w(* ? { } [ ]).any? { |sym| abs_path.include?(sym) }
+          found = Dir.glob(abs_path)
+          found.each do |file|
+            process_file(file)
+          end
+
+          puts 'Success'.green unless found.empty?
+          puts 'Noting found'.yellow if found.empty?
+        else
+          puts "Doesn't exist -> skipping".yellow
+        end
+      end
+
+      @ignored_items = nil
+      @current_item = nil
+    end
+
+    def _ok_path?(path)
+      @ignored_items.all? do |ignore_path|
+        !File.fnmatch(ignore_path, path, File::FNM_PATHNAME)
+      end
+    end
+
+    def _process_directory(path)
+      return unless File.directory?(path)
+
+      dir = @file_system.add_dir(path)
+
+      FileOperations.dir_entries(path).each do |subitem|
+        subitem_abs_path = File.join(path, subitem)
+
+        if File.directory?(subitem_abs_path)
+          dir[subitem] = _process_directory(subitem_abs_path)
+        elsif File.file?(subitem_abs_path)
+          file_entry = _process_file(subitem_abs_path)
+
+          if file_entry.nil?
+            dir.ignored_entries[subitem] = FileEntry.new(subitem, subitem_abs_path)
+          else
+            dir[subitem] = file_entry
+          end
+        end
+      end
+
+      dir
+    end
+
+    # @param [String] path
+    #
+    def process_directory(path)
+      entry = _process_directory(path)
+      @parsed_entries << entry unless entry.nil?
+    end
+
+    # @param [String] path
+    #
+    def _process_file(path)
+      return unless File.file?(path)
+
+      @file_system.add_file(path) if _ok_path?(path)
+    end
+
+    # @param [String] path
+    #
+    def process_file(path)
+      entry = _process_file(path)
+      @parsed_entries << entry unless entry.nil?
+    end
+
+    def copy_entry_to_dest(entry)
+      dest_path = destination_path_from(entry.absolute_path)
+      dest_dir  = File.dirname(dest_path)
+      src_path  = entry.absolute_path
+      FileUtils.mkdir_p(dest_dir)
+
+      case entry
+      when FileEntry
+        puts "Copying file #{src_path}".green
+        FileOperations.copy_item(src_path, dest_path)
+        @copied_paths << src_path
+      when DirEntry
+        if entry.recursive_ignored_empty?
+          puts "Copying directory #{src_path}".green
+          FileOperations.copy_item(src_path, dest_path)
+          @copied_paths << src_path
+        else
+          sub_entries = entry.recursive_entries
+          return if sub_entries.empty?
+
+          puts "Start copying all files in directory #{src_path}".green
+          sub_entries.each do |sub_entry|
+            copy_entry_to_dest(sub_entry)
+          end
+        end
+      end
+    end
+
+    # @param source_path [String] path to file/folder
+    #
+    # @return [String]
+    #
+    def destination_path_from(source_path)
+      File.join(@destination_path, BACKUP_DATA_BASE_PATH, source_path)
+    end
+
+    def save_info
+      info = {
+          env: ENV.to_hash,
+          copied_paths: @copied_paths,
+          orig_config_path: @config.path,
+      }
+
+      File.write(File.join(@destination_path, BACKUP_INFO_BASE_PATH), info.to_yaml)
+    end
+  end
+end

data/lib/raz/config_file.rb

@@ -0,0 +1,74 @@
+
+require_relative 'items/group'
+require_relative 'items/application'
+
+module Raz
+  class ConfigFile
+
+    # @return [String]
+    #
+    attr_reader :path
+
+    # @return [Array<Raz::Items::Group>]
+    #
+    attr_reader :items
+
+    # @return [Array<String>]
+    #
+    attr_reader :ignored_paths
+
+    # @return [Hash<Symbol, Array<Proc>>]
+    #
+    attr_reader :procs
+
+    # @param path [String] path to configuration file
+    #
+    def initialize(path = nil, &block)
+      @path = path
+      @items = []
+      @ignored_paths = []
+      @procs = {}
+
+      if block_given?
+        instance_eval(&block)
+      else
+        instance_eval(File.read(path), path)
+      end
+    end
+
+    # API
+
+    def group(name, &block)
+      @items << Raz::Items::Group.new(name, &block)
+    end
+
+    def app(name, &block)
+      @items << Raz::Items::Application.new(name, &block)
+    end
+
+    def ignore_path(path)
+      @ignored_paths << path
+    end
+
+
+    def before_backup(&block)
+      @procs[:before_backup] ||= []
+      @procs[:before_backup] << block
+    end
+
+    def after_backup(&block)
+      @procs[:after_backup] ||= []
+      @procs[:after_backup] << block
+    end
+
+    def before_restore(&block)
+      @procs[:before_restore] ||= []
+      @procs[:before_restore] << block
+    end
+
+    def after_restore(&block)
+      @procs[:after_restore] ||= []
+      @procs[:after_restore] << block
+    end
+  end
+end

data/lib/raz/constants.rb

@@ -0,0 +1,22 @@
+
+module Raz
+  module Constants
+    CONFIG_FOLDER_BASE_PATH = '.raz'
+    CONFIG_FILE_BASE_PATH = File.join(CONFIG_FOLDER_BASE_PATH, 'config.rb')
+
+    def config_path(home = Dir.home)
+      File.join(home, CONFIG_FILE_BASE_PATH)
+    end
+
+    # ======= backup paths ================
+
+    BACKUP_CONFIG_FOLDER_BASE_PATH = 'config'
+
+    def backup_config_file_path(backup_path)
+      File.join(backup_path, BACKUP_CONFIG_FOLDER_BASE_PATH, 'config.rb')
+    end
+
+    BACKUP_DATA_BASE_PATH = 'data'
+    BACKUP_INFO_BASE_PATH = 'raz_info.yaml'
+  end
+end

data/lib/raz/entries.rb

@@ -0,0 +1,139 @@
+
+module Raz
+  class FileSystem
+    # @return [DirEntry]
+    #
+    attr_reader :root_entry
+
+    def initialize
+      @root_entry = DirEntry.new('/', '/')
+    end
+
+    # @param [String | Array<String>] path  path to folder to create
+    #
+    # @return [DirEntry] dir entry for given path
+    #
+    def make_dir_p(path)
+      components = path.split(File::SEPARATOR).reject(&:empty?)
+
+      current = root_entry
+      components.each do |dir|
+        entry        = current[dir]
+        current[dir] = entry = DirEntry.new(dir, path) if entry.nil?
+        current      = entry
+      end
+
+      current
+    end
+
+    # @param [String] path
+    #
+    # @return [DirEntry]
+    #
+    def add_dir(path)
+      make_dir_p(path)
+    end
+
+    # @param [String] path
+    #
+    # @return [FileEntry]
+    #
+    def add_file(path)
+      entry = make_dir_p(File.dirname(path))
+
+      file_entry = FileEntry.new(File.basename(path), path)
+      entry[File.basename(path)] = file_entry
+    end
+  end
+
+  class DirEntry
+    # @return [Hash<String, FileEntry | DirEntry>]
+    #
+    attr_accessor :entries
+
+    # @return [Hash<String, FileEntry | DirEntry>]
+    #
+    attr_accessor :ignored_entries
+
+    # @return [String]
+    #
+    attr_reader :name
+
+    # @return [String]
+    #
+    attr_reader :absolute_path
+
+    # @param [String] name
+    #
+    def initialize(name, absolute_path)
+      @name            = name
+      @absolute_path   = absolute_path
+      @entries         = {}
+      @ignored_entries = {}
+    end
+
+    def [](key)
+      @entries[key]
+    end
+
+    def []=(key, value)
+      @entries[key] = value
+    end
+
+    def ==(other)
+      name == other.name && entries == other.entries
+    end
+
+    # @return [Bool]
+    #
+    def recursive_ignored_empty?
+      return false unless ignored_entries.empty?
+
+      dir_entries.all? do |key, entry|
+        entry.recursive_ignored_empty?
+      end
+    end
+
+    # @return [Hash<String, FileEntry | DirEntry>]
+    #
+    def dir_entries
+      entries.select { |_k, v| v.is_a?(DirEntry) }
+    end
+
+    # @return [Hash<String, FileEntry | DirEntry>]
+    #
+    def file_entries
+      entries.select { |_k, v| v.is_a?(FileEntry) }
+    end
+
+    # @return [Array<FileEntry | DirEntry>]
+    #
+    def recursive_entries
+      all_entries = []
+
+      all_entries += entries.values
+      all_entries += dir_entries.values.flat_map(&:recursive_entries)
+
+      all_entries
+    end
+  end
+
+  class FileEntry
+    attr_reader :name
+
+    attr_reader :absolute_path
+
+    def initialize(name, absolute_path)
+      @name          = name
+      @absolute_path = absolute_path
+    end
+
+    def ==(other)
+      absolute_path == if other.is_a?(FileEntry)
+                         other.absolute_path
+                       else
+                         other.to_s
+                       end
+    end
+  end
+end

data/lib/raz/file_operations.rb

@@ -0,0 +1,39 @@
+
+module Raz
+  module FileOperations
+    class NotExistingFile < ::StandardError; end
+    class UnknownFileType < ::StandardError; end
+
+    # Method to copy file and keep same informations (owner, mtime, ...) as original file
+    #
+    # @param src [String]
+    # @param dest [String]
+    #
+    def copy_item(src, dest)
+      if !File.exist?(src)
+        raise NotExistingFile, "Unknown file type for source #{src}"
+      elsif File.directory?(src)
+        FileUtils.cp_r(src, dest, preserve: true)
+      elsif File.file?(src)
+        FileUtils.cp(src, dest, preserve: true)
+      else
+        raise UnknownFileType, "Unknown file type for source #{src}"
+      end
+    end
+
+    module_function :copy_item
+
+    # @param path [String] path to folder
+    #
+    # @return [Array<String>]
+    #
+    def dir_entries(path)
+      entries = Dir.entries(path)
+      entries.delete('.')
+      entries.delete('..')
+      entries
+    end
+
+    module_function :dir_entries
+  end
+end

data/lib/raz/items/application.rb

@@ -0,0 +1,9 @@
+module Raz
+  module Items
+    require_relative 'group'
+
+    class Application < Group
+
+    end
+  end
+end

data/lib/raz/items/group.rb

@@ -0,0 +1,43 @@
+module Raz
+  module Items
+    class Group
+
+      # @return [String]
+      #
+      attr_reader :name
+
+      # @return [Array<String>]
+      #
+      attr_reader :paths
+
+      # @return [Array<String>]
+      #
+      attr_reader :ignored_paths
+
+      # @param name [String] name of this group
+      # @param block [Proc] block where is specified all paths
+      #
+      def initialize(name, &block)
+        @name = name
+        @paths = []
+        @ignored_paths = []
+
+        instance_eval(&block) unless block.nil?
+      end
+
+      ## API
+
+      # @param path [String] path to file
+      #
+      def path(path)
+        @paths << path
+      end
+
+      # @param path [String] path to file
+      #
+      def ignore_path(path)
+        @ignored_paths << path
+      end
+    end
+  end
+end

data/lib/raz/restorer.rb

@@ -0,0 +1,72 @@
+
+require 'yaml'
+require_relative 'file_operations'
+require_relative 'constants'
+
+include Raz::Constants
+
+
+module Raz
+  class Restorer
+
+    # @return [String]
+    #
+    attr_reader :source_path
+
+    # @param source_path [String]
+    #
+    def initialize(source_path)
+      @source_path = source_path
+    end
+
+    def restore
+      # load saved information from YAML
+      @info = YAML.load(File.read(File.join(@source_path, BACKUP_INFO_BASE_PATH)))
+      @orig_home_path = @info[:env]['HOME']
+
+      # load config file
+      config = ConfigFile.new(backup_config_file_path(@source_path))
+
+      # run before procs
+      (config.procs[:before_restore] || []).each do |proc|
+        instance_eval &proc
+      end
+
+      # restore all files
+      @info[:copied_paths].each do |src|
+        dest = destination_path_from_original(src)
+        src = File.join(@source_path, BACKUP_DATA_BASE_PATH, src)
+
+        if File.directory?(dest)
+          FileOperations.dir_entries(src).each do |item|
+            puts "Restoring file to #{File.join(src, item)}".green
+            FileOperations.copy_item(File.join(src, item), File.join(dest, item))
+          end
+        else
+          FileUtils.rmtree(dest) if File.exist?(dest)
+
+          puts "Restoring item to #{dest}".green
+          FileOperations.copy_item(src, dest)
+        end
+      end
+
+      # restore config file to previous location
+      FileOperations.copy_item(config.path, destination_path_from_original(@info[:orig_config_path]))
+
+      # run after procs
+      (config.procs[:after_restore] || []).each do |proc|
+        instance_eval &proc
+      end
+    end
+
+    private
+
+    # @param path [String]
+    #
+    # @return [String]
+    #
+    def destination_path_from_original(path)
+      path.sub(/^#{Regexp.escape(@orig_home_path)}/, ENV['HOME'])
+    end
+  end
+end

data/lib/raz/version.rb

@@ -0,0 +1,3 @@
+module Raz
+  VERSION = "0.1.0"
+end

data/lib/raz.rb

@@ -0,0 +1,11 @@
+
+module Raz
+  require 'raz/version'
+  require 'raz/constants'
+
+  require 'raz/file_operations'
+  require 'raz/config_file'
+
+  require 'raz/backuper'
+  require 'raz/restorer'
+end

data/raz.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'raz/version'
+
+
+Gem::Specification.new do |spec|
+  spec.name          = 'raz'
+  spec.version       = Raz::VERSION
+  spec.authors       = ['Roman Kříž']
+  spec.email         = ['samnung@gmail.com']
+
+  spec.summary       = 'Tool to backup and restore files.'
+  spec.homepage      = 'https://github.com/samnung/raz'
+  spec.license       = 'MIT'
+
+  spec.files         = Dir['bin/**/*'] + Dir['lib/**/*.rb'] + %w(raz.gemspec Gemfile LICENSE.txt README.md)
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'gli', '~> 2.13'
+  spec.add_runtime_dependency 'colorize', '~> 0.7'
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.3'
+  spec.add_development_dependency 'fakefs', '~> 0.6'
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: raz
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Roman Kříž
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description: 
+email:
+- samnung@gmail.com
+executables:
+- raz
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- bin/raz
+- lib/raz.rb
+- lib/raz/backuper.rb
+- lib/raz/config_file.rb
+- lib/raz/constants.rb
+- lib/raz/entries.rb
+- lib/raz/file_operations.rb
+- lib/raz/items/application.rb
+- lib/raz/items/group.rb
+- lib/raz/restorer.rb
+- lib/raz/version.rb
+- raz.gemspec
+homepage: https://github.com/samnung/raz
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Tool to backup and restore files.
+test_files: []
+has_rdoc: