siba 0.4.3

data/lib/siba/plugins/plugins.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+
+require 'siba/plugins/plugin_loader.rb'
+require 'siba/plugins/installed_plugins.rb'
+
+module Siba
+  class Plugins
+    PLUGINS_HASH = Siba::OptionsLoader.load_hash_from_yml(File.expand_path "../plugins.yml", __FILE__)
+    CATEGORIES = PLUGINS_HASH.keys
+
+    class << self
+      def valid_category?(category)
+        Siba::Plugins::CATEGORIES.include? category
+      end
+
+      def categories_str
+        Siba::Plugins::CATEGORIES.join(", ")
+      end
+
+      def category_and_type_correct?(category, type)
+        PLUGINS_HASH.keys.include?(category) && PLUGINS_HASH[category].keys.include?(type)
+      end
+
+      def plugin_description(category, type)
+        unless category_and_type_correct? category, type
+          raise Siba::Error, "Incorrect category '#{category}' or type '#{type}'."
+        end
+        PLUGINS_HASH[category][type]
+      end
+
+      def plugin_type_and_description(category, type, name_column_length)
+        desc = plugin_description category, type
+        sprintf("%-#{name_column_length}s %s", type, desc)
+      end
+
+      def get_list
+        str = ""
+        all_names = PLUGINS_HASH.values.map{|a| a.keys}.flatten
+        max_name_length = all_names.max do |a,b|
+          a.length <=> b.length
+        end.length + 5
+
+        PLUGINS_HASH.each do |category, plugins|
+          str << "#{category.capitalize}"
+          str << "s" if plugins.size > 1
+          str << ":\n"
+          plugins.each do |type, desc|
+            installed = InstalledPlugins.installed?(category, type) ? "*" : " "
+            str << " #{installed} #{plugin_type_and_description(category, type, max_name_length)}\n"
+          end
+          str << "\n"
+        end
+        str
+      end
+    end
+  end
+end

data/lib/siba/plugins/plugins.yml

@@ -0,0 +1,9 @@
+source:
+  files: Backup local files and directories
+archive:
+  tar: Archive with optional gzip or bzip2 compression
+encryption:
+  gpg: Encrypt with AES256, Blowfish, Twofish, 3DES and other ciphers
+destination:
+  dir: Backup to local directory
+  aws-s3: Upload backup to Amazon S3 storage

data/lib/siba/plugins/source/files/files.rb

@@ -0,0 +1,166 @@
+# encoding: UTF-8
+
+module Siba::Source
+  module Files
+    class Files
+      include Siba::LoggerPlug
+      include Siba::FilePlug
+      attr_accessor :files_to_include, :ignore, :include_subdirs
+
+      def initialize(files_to_include, ignore, include_subdirs)
+        @files_to_include = files_to_include
+        @ignore = ignore
+        @include_subdirs = include_subdirs
+      end
+
+      def backup(dest_dir)
+        siba_file.run_this "backup" do
+          size_digits = files_to_include.size.to_s.length
+          files_to_include.each_index do |i|
+            file = files_to_include[i]
+            file = siba_file.file_expand_path file
+            next if ignored? file
+            
+            is_file = siba_file.file_file? file
+            unless is_file || siba_file.file_directory?(file)
+              logger.error "Source file or directory does not exist: #{file}"
+              next
+            end
+
+            path_to_subdir = Files.sub_dir_name i+1, size_digits, is_file, file, dest_dir
+            siba_file.file_utils_mkpath path_to_subdir 
+
+            logger.debug file
+            if is_file
+              copy_file file, path_to_subdir
+            else
+              copy_dir file, path_to_subdir, false
+            end
+          end
+        end
+      end
+
+      def restore(from_dir)
+        siba_file.run_this do
+          backup_dirs = Siba::FileHelper.entries(from_dir).select do |e|
+            siba_file.file_directory? File.join(from_dir, e)
+          end.sort
+
+          if backup_dirs.size != files_to_include.size
+            raise Siba::Error, "Number of source files does not equal the number of files that are in the backup"
+          end
+
+          backup_dirs.each_index do |i|
+            backup_dir = backup_dirs[i]
+            splitted = backup_dir.split "-"
+            if splitted.size < 3
+              logger.error "Failed to parse backup dir #{backup_dir}"
+              next
+            end
+            dir_or_file = splitted[1]
+            if dir_or_file != "dir" && dir_or_file != "file"
+              logger.error "Failed to parse backup dir #{backup_dir}"
+              next
+            end
+            is_dir = dir_or_file == "dir"
+            path_to_backup_dir = File.join from_dir, backup_dir
+            entry_name_to_restore = files_to_include[i]
+            path_to_source = siba_file.file_expand_path entry_name_to_restore
+            if is_dir
+              siba_file.file_utils_mkpath path_to_source
+              siba_file.file_utils_cp_r File.join(path_to_backup_dir, "."), path_to_source
+              logger.info "Dir: #{path_to_source}"
+            else
+              restore_file path_to_backup_dir, entry_name_to_restore, path_to_source
+            end
+          end
+        end
+      end
+
+      def restore_file(path_to_backup_dir, entry_name_to_restore, path_to_source)
+        backup_dir_entries = Siba::FileHelper.entries path_to_backup_dir
+        if backup_dir_entries.size != 1 
+          logger.error "Failed to restore file: #{entry_name_to_restore}"
+          return
+        end
+
+
+        backup_file_name = backup_dir_entries[0]
+        path_to_backup_file = File.join path_to_backup_dir, backup_file_name
+        unless siba_file.file_file? path_to_backup_file
+          logger.error "Failed to restore file: #{path_to_backup_file}"
+          return
+        end
+        source_file_name = File.basename path_to_source
+        unless source_file_name == backup_file_name
+          logger.error "Failed to restore file, source file name '#{source_file_name}' is not the same as backup file name #{backup_file_name}"
+          return
+        end
+        path_to_source_dir = File.dirname path_to_source
+        siba_file.file_utils_mkpath path_to_source_dir
+        siba_file.file_utils_cp path_to_backup_file, path_to_source_dir
+        logger.info "File: #{path_to_source}"
+      end
+
+      def copy_file(file, dest_dir)
+        siba_file.run_this "copy file" do
+          return if ignored? file
+          siba_file.file_utils_cp(file, dest_dir) 
+        end
+      end
+
+      def copy_dir(dir, dest_dir, create_subdir=false)
+        siba_file.run_this "copy dir" do
+          return if ignored? dir
+
+          if create_subdir
+            dest_dir = File.join(dest_dir, File.basename(dir))
+            siba_file.file_utils_mkpath dest_dir
+          end
+
+          Siba::FileHelper.entries(dir).each do |entry|
+            entry = File.join dir, entry
+            if siba_file.file_file? entry
+              copy_file entry, dest_dir 
+            elsif  siba_file.file_directory? entry
+              copy_dir entry, dest_dir, true if include_subdirs
+            else
+              logger.error "Failed to backup: #{file}."
+            end
+          end 
+        end
+      end
+
+      def ignored?(file)
+        return false if ignore.nil?
+        ignore.each do |pattern|
+          if Siba::Source::Files::Files.path_match? pattern, file
+            logger.info "Ignoring #{file}"
+            return true
+          end
+        end
+        false
+      end
+
+      class << self
+        def path_match?(pattern, file)
+          file.strip!
+          pattern.strip!
+          basename = File.basename(file)
+          
+          return File.fnmatch(pattern, basename, File::FNM_CASEFOLD) || # match basename against pattern
+            File.fnmatch(pattern, file, File::FNM_CASEFOLD) # match whole path against pattern
+        end
+
+        def sub_dir_name(num, size_digits, is_file, src_file, dest_dir)
+          basename = File.basename src_file
+          basename = "root" if basename.empty? || basename == "/"
+          sub_dir_name = "%0#{size_digits}d" % num
+          sub_dir_name += is_file ? "-file" : "-dir"
+          sub_dir_name += "-#{basename}"
+          File.join dest_dir, sub_dir_name
+        end
+      end
+    end
+  end
+end

data/lib/siba/plugins/source/files/init.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+require 'siba/plugins/source/files/files'
+
+module Siba::Source
+  module Files
+    class Init 
+      include Siba::LoggerPlug
+      attr_accessor :files
+
+      def initialize(options)
+        files_to_include = Siba::SibaCheck.options_string_array options, "include"
+        ignore = Siba::SibaCheck.options_string_array options, "ignore", true
+        include_subdirs = Siba::SibaCheck.options_bool options, "include_subdirs", true, true
+        @files = Siba::Source::Files::Files.new files_to_include, ignore, include_subdirs
+      end
+
+      # Collect sources and put them into dest_dir
+      # No return value is expected
+      def backup(dest_dir)
+        logger.info "Collecting files"
+        @files.backup dest_dir
+      end
+
+      # Restore source files and dirs from_dir 
+      # No return value is expected
+      def restore(from_dir)
+        logger.info "Restoring files"
+        @files.restore from_dir
+      end
+    end
+  end
+end

data/lib/siba/plugins/source/files/options.yml

@@ -0,0 +1,11 @@
+include:
+- /dir          
+- /dir/file     
+- ~/file        # relative to home dir  
+- file          # relative to this options file
+ignore:
+- "*.log"
+- ".*"
+- file_name
+- dir_name
+include_subdirs: Yes

data/lib/siba/restore.rb

@@ -0,0 +1,113 @@
+# encoding: UTF-8
+
+module Siba
+  class Restore
+    include Siba::LoggerPlug
+    include Siba::FilePlug
+    include Siba::KernelPlug
+
+    def restore(path_to_options_yml)
+      run_restore path_to_options_yml
+    ensure
+      Siba.cleanup
+    end
+
+private
+
+    def run_restore(path_to_options_yml)
+      LoggerPlug.create "Restore", nil
+      options = Siba::OptionsLoader.load_yml path_to_options_yml
+      Siba.current_dir = File.dirname path_to_options_yml
+      Siba.settings = options["settings"] || {}
+      Siba.backup_name = File.basename path_to_options_yml, ".yml"
+      TmpDir.test_access 
+      tasks = SibaTasks.new options, path_to_options_yml, true
+      file_name = get_backup_choice tasks 
+      unless file_name.nil?
+        if user_wants_to_proceed?
+          tasks.restore file_name
+        else
+          logger.show_finish_message = false
+          logger.info "Cancelled by user"
+        end
+      end
+      Siba.cleanup_tmp_dir
+    rescue Exception => e 
+      logger.fatal e
+      logger.log_exception e, true
+    end
+
+    def get_backup_choice(tasks)
+      list = tasks.get_backups_list
+
+      siba_file.run_this do
+        if list.empty?
+          logger.show_finish_message = false
+          logger.info "No backups named '#{Siba.backup_name}' found"
+          return
+        end
+
+        if list.size == 1
+          return list[0][0]
+        else
+          list.sort_by!{|a| a[1]}
+          siba_kernel.puts "\nAvailable '#{Siba.backup_name}' backups:\n"
+          show_backups list
+          file_name = get_backup_user_choice list
+
+          if file_name.nil?
+            logger.show_finish_message = false
+            logger.info "Cancelled by user"
+          end
+          return file_name
+        end
+      end
+    end
+
+    def show_backups(list)
+      list.map! {|a| a << Siba::StringHelper.format_time(a[1])}
+      max_date_length = list.max do |a,b|
+        a[2].length <=> b[2].length
+      end[2].length + 5
+
+      rows = list.size / 2 + list.size % 2
+      1.upto(rows) do |i|
+        num1 = "#{i.to_s.rjust(2)}."
+        str1 = list[i-1][2]
+        column1 = sprintf("%s %-#{max_date_length}s", num1, str1)
+
+        if (i+rows) <= list.size
+          num2 = "#{(i+rows).to_s.rjust(2)}."
+          str2 = list[i+rows-1][2] 
+          column2 = "#{num2} #{str2}"
+        end
+        siba_kernel.puts " #{column1}#{column2}"
+      end
+    end
+
+    def user_wants_to_proceed?
+      siba_kernel.printf "\nWarning: backup will be restored into your original source location.
+Your current source data will be overwritten and WILL BE LOST.
+Type 'yes' if you want to proceed:
+(yes/n) > "
+      user_choice = siba_kernel.gets.chomp.strip
+      return user_choice.downcase == "yes"
+    end
+
+    def get_backup_user_choice(list)
+      msg = "\nChoose a backup to restore.\nEnter backup number from 1 to #{list.size}, or 0 to exit.\n> "
+      siba_kernel.printf msg
+      while true
+        user_choice = siba_kernel.gets.chomp.strip
+        number = Integer(user_choice) rescue -1
+        if number >= 0 && number <= list.size
+          return if number == 0
+          return list[number-1][0]
+        else
+          siba_kernel.printf msg
+        end 
+      end
+    end
+
+  end
+end

data/lib/siba/scaffold.rb

@@ -0,0 +1,166 @@
+# encoding: UTF-8
+
+module Siba
+  class Scaffold
+    include Siba::FilePlug
+    include Siba::LoggerPlug
+    attr_accessor :category, :name, :name_camelized
+    CATEGORY_REPLACE_TEXT = "c6y"
+    NAME_REPLACE_TEXT = "demo"
+    
+    def initialize(category, name)
+      @category = category
+      unless Siba::Plugins.valid_category? category
+        raise Siba::Error, "Invalid category '#{category}'. Available categories are: #{Siba::Plugins.categories_str}"
+      end
+
+      @name = Siba::StringHelper.str_to_alphnumeric name
+      raise Siba::Error, "first character of gem name can not be number" if name =~ /^[0-9]/
+
+      @name_camelized = StringHelper.camelize name
+    end
+
+    def scaffold(dest_dir)
+      run_scaffold dest_dir
+    ensure
+      Siba.cleanup
+    end
+
+    private
+
+    def run_scaffold(dest_dir)
+      siba_file.run_this "scaffold" do
+        LoggerPlug.create "Scaffolding", nil, false
+        logger.debug "Scaffolding started"
+        dest_dir = File.join dest_dir, name
+        if siba_file.file_directory?(dest_dir) || siba_file.file_file?(dest_dir)
+          raise Siba::Error, "Directory already exists #{dest_dir}." 
+        end
+
+        logger.debug "Checking if GIT is installed"
+        raise Siba::Error, "Please install GIT first" unless siba_file.shell_ok? "git help"
+        scaffolds_dir = siba_file.file_expand_path "../../../scaffolds", __FILE__
+        
+        logger.debug "Creating a tmp dir"
+        dest_tmp_dir = Siba::TestFiles.mkdir_in_tmp_dir "scaffold"
+
+        logger.debug "Copying project files"
+        project_dir = File.join scaffolds_dir, "project"
+        unless siba_file.file_directory? project_dir
+          raise Siba::Error, "Scaffold project dir does not exist '#{project_dir}'"
+        end
+        siba_file.file_utils_cp_r File.join(project_dir,"."), dest_tmp_dir
+        
+        logger.debug "Copying init file"
+        init_file = File.join scaffolds_dir, "#{category}.rb"
+        unless siba_file.file_file? init_file
+          raise Siba::Error, "Scaffold init file does not exist '#{init_file}'"
+        end
+        init_dir = File.join dest_tmp_dir, "lib", "siba-#{CATEGORY_REPLACE_TEXT}-demo"  
+        unless siba_file.file_directory? init_dir
+          raise Siba::Error, "Source dir does not exist '#{init_dir}'"
+        end
+        init_file_dest = File.join init_dir,"init.rb"
+        siba_file.file_utils_cp init_file, init_file_dest 
+        unless siba_file.file_file? init_file_dest
+          raise Siba::Error, "Filed to create init file '#{init_file_dest}'"
+        end
+
+        logger.debug "Writing examples to init.rb"
+        replace_init_examples scaffolds_dir, init_file_dest
+
+        logger.debug "Setting siba gem dependency"
+        replace_siba_version dest_tmp_dir
+
+        logger.debug "Setting gem category and name in file names and contents"
+        replace_category_and_name dest_tmp_dir        
+
+        gitify dest_tmp_dir
+       
+        logger.debug "Copying the project to destination"
+        siba_file.file_utils_mkpath dest_dir
+        siba_file.file_utils_cp_r File.join(dest_tmp_dir,"."), dest_dir
+
+        
+        logger.info "Project created in #{dest_dir}"
+        logger.info "There is a README file with instructions there"
+        logger.show_finish_message = false
+      end
+    rescue Exception => e 
+      logger.fatal e
+      logger.log_exception e, true
+    end
+
+    def replace_category_and_name(dir)
+      Siba::FileHelper.entries(dir).each do |entry|
+        entry_path = replace_path dir, entry
+        if siba_file.file_directory? entry_path
+          replace_category_and_name entry_path 
+        else
+          replace_file_contents entry_path
+        end
+      end
+    end
+
+    def replace_path(dir, entry)
+      entry_path = File.join dir, entry
+      entry_after = entry.gsub CATEGORY_REPLACE_TEXT, category 
+      entry_after = entry_after.gsub NAME_REPLACE_TEXT, name 
+      if entry_after != entry
+        entry_path_after = File.join(dir, entry_after)
+        siba_file.file_utils_mv entry_path, entry_path_after
+        entry_path = entry_path_after
+      end
+      entry_path
+    end
+
+    def replace_file_contents(path_to_file)
+      return unless siba_file.file_file? path_to_file
+      Siba::FileHelper.change_file(path_to_file) do |file_text|
+        file_text.gsub! CATEGORY_REPLACE_TEXT, category 
+        file_text.gsub! CATEGORY_REPLACE_TEXT.capitalize, category.capitalize
+        file_text.gsub! NAME_REPLACE_TEXT, name 
+        file_text.gsub! NAME_REPLACE_TEXT.capitalize, name_camelized 
+        file_text
+      end
+    end
+
+    def gitify(path_to_project)
+      logger.debug "Initializing GIT repository"
+      siba_file.file_utils_cd path_to_project
+      siba_file.run_shell "git init", "Failed to init git repository"
+      siba_file.run_shell "git add ."
+      siba_file.run_shell "git commit -a -m 'Initial commit'"
+    end
+
+    def replace_siba_version(project_dir)
+      path_to_gemspec = File.join project_dir, "siba-c6y-demo.gemspec"
+      raise Siba::Error, "Can not find gemspec file #{path_to_gemspec}" unless siba_file.file_file? path_to_gemspec
+      Siba::FileHelper.change_file(path_to_gemspec) do |file_text|
+        version = Siba::VERSION.split('.')[0..-2].join('.')
+        file_text.gsub "siba_version", version 
+      end
+    end
+
+    def replace_init_examples(scaffolds_dir, init_file_dest)
+      replace_init_example scaffolds_dir, init_file_dest, "init_example.rb"
+      replace_init_example scaffolds_dir, init_file_dest, "examples.rb"
+    end
+
+    def replace_init_example(scaffolds_dir, init_file_dest, example_file_name)
+      shared_dir = siba_file.file_expand_path File.join(scaffolds_dir, "shared")
+      init_example_file = File.join shared_dir, example_file_name
+      unless siba_file.file_file? init_example_file
+        raise Siba::Error, "Can not find init example file: '#{init_example_file}'"
+      end
+      init_example = Siba::FileHelper.read init_example_file
+      Siba::FileHelper.change_file(init_file_dest) do |f|
+        replace_text = "## #{example_file_name} ##"
+        unless f.include? replace_text
+          raise Siba::Error, "Can not replacement text: #{replace_text}"
+        end
+        f.gsub! replace_text, init_example
+      end
+    end
+  end
+end