siba 0.4.3

data/lib/siba/globals.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+module Siba
+
+  class << self
+    include Siba::TmpDirPlug
+    include Siba::FilePlug
+
+    attr_accessor :settings, :backup_name, :current_dir
+    Siba.settings = {}
+    Siba.current_dir = Siba::FilePlug.siba_file.file_utils_pwd
+
+    def cleanup
+      Siba.cleanup_tmp_dir
+    ensure
+      LoggerPlug.close
+    end
+  end
+end

data/lib/siba/helpers/encoding_helper.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+module Siba
+  class EncodingHelper
+    EXTERNAL_ENCODING = Encoding.find "external"
+    INTERNAL_ENCODING = Encoding::UTF_8
+
+    class << self
+      def encode_to_external(value)
+        encode value, EXTERNAL_ENCODING, INTERNAL_ENCODING
+      end
+
+      protected
+
+      def encode(value, dst_encoding, src_encoding=nil)
+        return encode_str value, dst_encoding, src_encoding if value.instance_of? String
+        return encode_array value, dst_encoding, src_encoding if value.instance_of? Array
+        value
+      end
+
+      def encode_str(str, dst_encoding, src_encoding=nil)
+        return nil if str.nil?
+        return str unless str.instance_of? String
+        if str.encoding != dst_encoding
+          str = str.encode(dst_encoding, src_encoding, {:invalid => :replace, :undef => :replace}) 
+        end
+        str
+      end
+
+      def encode_array(array, dst_encoding, src_encoding=nil)
+        return nil if array.nil?
+        return array unless array.instance_of? Array
+        array.map {|a| encode_str a, dst_encoding, src_encoding}
+      end
+    end
+  end
+end
+

data/lib/siba/helpers/file_helper.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+
+module Siba
+  class FileHelper
+    class << self
+      include Siba::FilePlug
+
+      def dir_empty?(dir)
+        entries(dir).empty?
+      end
+
+      def dirs_count(dir)
+        entries(dir).count do |a| 
+          siba_file.file_directory? File.join(dir, a)
+        end
+      end
+
+      # Reads a file in UTF-8 encoding
+      def read(file)
+        str = File.read file, { open_args: ["r:bom|utf-8"]}
+        unless str.valid_encoding?
+          raise Siba::Error, "Incorrect file encoding. Please save the options with UTF-8 encoding."
+        end
+        str
+      end
+
+      # Write to file in UTF-8 encoding
+      def write(file, data)
+        siba_file.file_utils_remove_entry_secure file if siba_file.file_file? file
+        siba_file.file_open(file, "w:utf-8") do |file|
+          file << data
+        end
+      end
+
+      # Used to replace text in file
+      # Example:
+      #   change_file("/path") do |file_text|
+      #     file_text.gsub "one", "two"
+      #   end
+      def change_file(path_to_file, &block)
+        file_text = Siba::FileHelper.read path_to_file
+        file_text = block.call file_text
+        Siba::FileHelper.write path_to_file, file_text
+      end
+
+      # Retuns an array containing all dir entires except '.' and '..' dirs
+      def entries(dir)
+        siba_file.dir_entries(dir) - %w{ . .. }
+      end
+
+      # Raises error if dirs are not identical 
+      def dirs_same?(dir1, dir2)
+        dir1_entries = siba_file.dir_entries dir1
+        dir2_entries = siba_file.dir_entries dir2
+        diff1 = (dir1_entries - dir2_entries).map{|i| File.join(dir1,i)}
+        diff2 = (dir2_entries - dir1_entries).map{|i| File.join(dir2,i)}
+        diff = diff1 + diff2
+        msg = "The directories '#{File.basename(dir1)}' and '#{File.basename(dir2)}' are different: "
+        raise Siba::Error, "#{msg}#{diff.take(10).join(', ')}" unless diff.empty?
+
+        # compare files and directories
+        dir1_entries.each do |dir|
+          next if dir == "." || dir == ".."
+          sub_dir1_entry = File.join dir1, dir
+          sub_dir2_entry = File.join dir2, dir
+
+          # compare files
+          if siba_file.file_file? sub_dir1_entry
+            raise "#{msg}'#{sub_dir2_entry}' is not a file" unless siba_file.file_file? sub_dir2_entry
+            unless siba_file.file_utils_compare_file sub_dir1_entry, sub_dir2_entry
+              raise Siba::Error, "#{msg}'#{sub_dir1_entry}' and '#{sub_dir2_entry}' files are different." 
+            end
+          end
+          
+          # compare permissions
+          if (siba_file.file_stat(sub_dir1_entry).mode % 01000) != (siba_file.file_stat(sub_dir2_entry).mode % 01000)
+            raise Siba::Error, "#{msg}'#{sub_dir1_entry}' and '#{sub_dir2_entry}' entries have different permissions." 
+          end
+
+          # compare sub-dirs
+          if siba_file.file_directory? sub_dir1_entry
+            raise Siba::Error, "#{msg}'#{sub_dir2_entry}' is not a directory" unless siba_file.file_directory? sub_dir2_entry
+            dirs_same? sub_dir1_entry, sub_dir2_entry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/siba/helpers/gem_helper.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+
+module Siba
+  class GemHelper
+    class << self
+      def all_local_gems
+        @local_gems ||= begin
+                           Gem::Specification.all = nil
+                           all = Gem::Specification.to_a
+                           Gem::Specification.reset
+                           all
+                        end
+      end
+
+      def gem_path(name)
+        gem_spec = all_local_gems.find {|a| a.name==name}
+        raise Siba::Error, "Gem #{name} is not installed" if gem_spec.nil?
+        gem_spec.full_gem_path
+      end
+    end
+  end
+end

data/lib/siba/helpers/password_strength.rb

@@ -0,0 +1,94 @@
+# encoding: UTF-8
+
+module Siba
+  # Password strength calculator based on: 
+  #   http://snippets.dzone.com/posts/show/4698
+  #   https://www.grc.com/haystack.htm
+  class PasswordStrength 
+    PASSWORD_SETS = {
+      /[a-z]/ => 26,
+      /[A-Z]/ => 26,
+      /[0-9]/ => 10,
+      /[^\w]/ => 33
+    }
+
+    AinB = {
+      second: 60,
+      minute: 60,
+      hour: 24,
+      day: 30,
+      month: 12,
+      year: 100,
+      century: 1
+    }
+
+    Illions = {
+      hundred: 100,
+      thousand: 10,
+      million: 1000,
+      billion: 1000,
+      trillion: 1000
+    }
+
+    TRIES_PER_SECOND = 100 * 10 ** 12 # 100 TFLOPS
+    AGE_OF_THE_UNIVERSE_SECONDS = 4.336 * 10 ** 17 # the best estimate in 2011
+
+    class << self
+      def seconds_to_crack(password)
+        set_size = 0
+        PASSWORD_SETS.each_pair {|k,v| set_size += v if password =~ k}
+        combinations = 0
+        1.upto(password.length) {|i| combinations += set_size ** i }
+        combinations.to_f / TRIES_PER_SECOND
+      end
+
+      # Password is considered weak if it takes less than a year to crack it
+      def is_weak?(seconds_to_crack)
+        seconds_to_crack < 60 * 60 * 24 * 365
+      end
+
+      # Convert the number of seconds human-friendly timespan string
+      # Example: 
+      #   130: 2 minutes
+      #   12345: 3 hours
+      def seconds_to_timespan(seconds)
+        return "forever" if seconds > AGE_OF_THE_UNIVERSE_SECONDS
+        ticks = seconds
+        AinB.each_pair do |a,b|
+          ticks_next = ticks.to_f / b
+          return get_timespan_str ticks, a if ticks_next < 1
+          ticks = ticks_next
+        end
+
+        # century or longer
+        ticks = ticks.floor
+        return get_timespan_str ticks, "century", "centuries" if ticks < 100
+        illion_unit, ticks = get_illions ticks
+        "#{ticks} #{illion_unit} centuries".strip
+      end
+
+      private
+
+      def get_timespan_str(ticks, unit, unit_plural=nil)
+        ticks = ticks.floor
+        return case
+          when ticks < 1 then "less than a #{unit}"
+          when ticks == 1 then "1 #{unit}"
+          else "#{ticks} #{unit_plural || unit.to_s+"s"}"
+        end
+      end
+
+      def get_illions(ticks)
+        illion_unit = ""
+        Illions.each_pair do |a,b|
+          ticks_next = ticks.to_f / b
+          break if ticks_next < 1 
+          illion_unit = a 
+          ticks = ticks_next
+        end
+
+        return illion_unit, ticks.floor
+      end
+    end
+  end
+end

data/lib/siba/helpers/security_helper.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+ 
+require 'securerandom'
+
+module Siba
+  class SecurityHelper
+    class << self
+      def generate_password_for_yaml(length = 16)
+        characters = (32..126).to_a - "\\\"".bytes.to_a
+
+        (0...length).map{      
+          characters[SecureRandom.random_number(characters.size)].chr
+        }.join                 
+      end
+
+      def alphanumeric_password(length = 16, lowercase_only=false, non_ambiguous = false)
+        characters = ('a'..'z').to_a + ('0'..'9').to_a
+        characters += ('A'..'Z').to_a unless lowercase_only
+
+        %w{I O l 0 1}.each{ |ambiguous_character| 
+          characters.delete ambiguous_character 
+        } if non_ambiguous     
+
+        (0...length).map{      
+          characters[SecureRandom.random_number(characters.size)]
+        }.join    
+      end
+    end   
+  end
+end

data/lib/siba/helpers/string_helper.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+
+module Siba
+  class StringHelper
+    class << self
+      # Helps to use a string in URLs and file names by
+      # replacing all non-alphanumeric characters with '-'
+      # and converting to lowercase
+      def str_to_alphnumeric(str)
+        str.downcase.gsub(/[^ a-z0-9]/,' ').strip.gsub(/ {1,}/,'-')
+      end
+
+      def nil_or_empty(str)
+        str.nil? || str.strip.empty?
+      end
+
+      # Convers a string to CamelCase. Based on Rails ActiveSupport::Inflector.camelize.
+      def camelize(str)
+        str = str.capitalize
+        str.gsub(/(?:_|-)([a-z\d]*)/i) { "#{$1.capitalize}" }
+      end
+
+      def escape_for_yaml(str)
+        str.gsub("\\","\\\\\\").gsub("\"","\\\"")
+      end
+
+      def format_time(time)
+        time.strftime("%B %e, %Y")
+      end
+    end
+  end
+end

data/lib/siba/helpers/test/extend_test.rb

@@ -0,0 +1,114 @@
+# encoding: UTF-8
+
+class MiniTest::Unit::TestCase
+  include Siba::FilePlug 
+  def must_log(level)
+    verify_log true, level, true
+  end
+
+  def wont_log(level)
+    verify_log false, level, true
+  end
+
+  def must_log_from(level)
+    verify_log true, level, false
+  end
+
+  def wont_log_from(level)
+    verify_log false, level, false
+  end
+
+  def show_log
+    puts Siba::SibaLogger.messages.map{|a| a.msg}.join("\n")
+  end
+
+  def mock_file(name, retval, args=[])
+    mock = new_mock_file
+    mock.expect name, retval, args 
+    mock
+  end
+
+  def new_mock_file
+    Siba::FilePlug.siba_file = MiniTest::Mock.new 
+  end
+
+  def create_plugin(yml_file_name_or_options_hash)
+    if yml_file_name_or_options_hash.is_a? String
+      load_options yml_file_name_or_options_hash
+    else
+      @options = yml_file_name_or_options_hash
+    end
+    
+    unless @plugin_category
+      raise Siba::Error, "Initialize '@plugin_category' variable (#{Siba::Plugins.categories_str})"
+    end
+
+    unless @plugin_type
+      raise Siba::Error, "Initialize '@plugin_type' variable with your gem name ('cloud', 'ftp' etc)."
+    end
+
+    Siba::PluginLoader.loader.load(@plugin_category, @plugin_type, @options)
+  end
+
+  def load_options(yml_name)
+    unless @yml_path
+      raise Siba::Error, "Initialize '@yml_path' variable with the dir to test YAML files."
+    end
+    yml_name = yml_name + ".yml" unless yml_name =~ /\.yml$/
+    @options = SibaTest.load_options File.join(@yml_path, yml_name)
+  end
+
+  def prepare_test_dir(dir_name_part, tmp_dir = nil)
+    tmp_dir ||= SibaTest.tmp_dir
+    Siba::TestFiles::prepare_test_dir dir_name_part, tmp_dir
+  end
+  
+  def prepare_test_file(file_name_part, tmp_dir = nil)
+    tmp_dir ||= SibaTest.tmp_dir
+    Siba::TestFiles::prepare_test_file file_name_part, tmp_dir
+  end
+
+  def generate_path(file_name_part, tmp_dir = nil)
+    tmp_dir ||= SibaTest.tmp_dir
+    Siba::TestFiles::generate_path file_name_part, tmp_dir
+  end
+
+  def mkdir_in_tmp_dir(prefix, tmp_dir = nil)
+    tmp_dir ||= SibaTest.tmp_dir
+    Siba::TestFiles::mkdir_in_tmp_dir prefix, tmp_dir
+  end
+
+  def dirs_same?(a,b)
+    Siba::FileHelper::dirs_same? a, b
+  end
+
+  def prepare_options(src_yml_path, replace_data)
+    Siba::TestFiles::prepare_options(src_yml_path, replace_data)
+  end
+  
+  def prepare_yml(src_yml_path, replace_data, tmp_dir=nil)
+    tmp_dir ||= SibaTest.tmp_dir
+    Siba::TestFiles::prepare_yml src_yml_path, replace_data, tmp_dir
+  end
+
+  private 
+
+  def verify_log(must_change, log_level, exact_level = true)
+    log_count = Siba::SibaLogger.count log_level, exact_level
+
+    if exact_level
+      message = "'#{log_level}' log messages"
+    else
+      message = "log messages"
+    end
+
+    if must_change
+      message = "Expected " + message
+      raise message if log_count == 0
+    else
+      message = "Unexpected " + message
+      raise message if log_count > 0
+    end
+  end
+end
+