tiny_backup 0.0.0 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2562bb50b04adc3aaf11fe40065fb8a02b89978b
+  data.tar.gz: 1572b687adee86d841f166122a5eb830bdef3ffc
+SHA512:
+  metadata.gz: 82dacfa4785f06dffc09e96845cf747ca83b9adac230870675ec3896054b2d2f8f0d49883802edd45607e4498196f598b89a2ba05959b165eb7179eb21257557
+  data.tar.gz: 3f9e1e98fcf364397c379bee209b4377a2eb267e9186d0255ba284ee2a7dfa5a3f536abb3445c34206a433967c1ae01cb49af0999f222409ea32c045bc547217

data/lib/configure.rb

@@ -0,0 +1,74 @@
+module TinyBackup
+  # Set global settings for TinyBackup like TinyBackup.configure {|config| config.max_versions = 100 }
+  def self.configure &block
+    yield @config ||= Config.new
+  end
+
+  # Global settings for TinyBackup
+  def config
+    @config ||= Config.new
+  end
+
+  class Config
+    # The folder name that is used to keep the backup files and temporary files.
+    # @return [String] defaults to "db/backup"
+    attr_accessor :backup_folder
+
+    # The date format that will be appended and used to time-stamp the backup files. Can be any valid date format similar with the ISO C and POSIX directives.
+    # @return [String] defaults to "%d-%m-%Y_%H:%M"
+    attr_accessor :date_format
+
+    # The prefix used to name each .diff file that contains changes from the last version. Automatically generated +version_number+ will be appended to the +version_prefix+.
+    # @return [String] defaults to "ver_"
+    attr_accessor :version_prefix
+
+    # The prefix used to name the starting .zip file that contains a schema.rb file and a .csv file for each non-empty table.
+    # @return [String] defaults to "origin"
+    attr_accessor :zip_prefix
+
+    # Maximum number of versions that can exist. If this number is exceeded, the first .diff version is merged in the starting .zip file and cannot be reversed.
+    # @return [Integer] defaults to 32 (if backup is done daily, keep the last month versions)
+    attr_accessor :max_versions
+
+    # Maximum number of rows fetched by a single query to avoid memory crashes. If your table has more rows it will be used multiple query to fetch all the data.
+    # @return [Integer] defaults to 100000
+    attr_accessor :per_page
+
+    # true if the debug info will be provided in the process.
+    # @return [Boolean] defaults to false
+    attr_accessor :silent
+
+    def initialize
+      @backup_folder  = "db/backup"
+      @date_format    = "%d-%m-%Y_%H:%M"
+      @version_prefix = "ver_"
+      @zip_prefix     = "origin"
+      @max_versions   = 32
+      @per_page       = 100000
+      @silent         = false
+    end
+
+    def backup_folder= val
+      @backup_folder = val.to_s[0..-2] if val.to_s.last == "/"
+    end
+
+    def backup_folder
+      unless @backup_folder_exist ||= File.directory?(@backup_folder)
+        FileUtils.mkdir(@backup_folder)
+        @backup_folder_exist = true
+      end
+
+      @backup_folder
+    end
+
+    def date_format= val
+      begin
+        Time.now.strftime(val).to_datetime
+      rescue
+        raise ArgumentError, "invalid date format"
+      end
+
+      @date_format = val
+    end
+  end
+end

data/lib/tiny_backup.rb

@@ -10,96 +10,18 @@ end
 require 'rake'
 require 'csv'
 
-module TinyBackup
-  # Get configuration settings
-  #
-  # Returns a *hash* with the following keys backup_folder, date_format, version_prefix, zip_prefix, max_versions, per_page
-  def config
-    {
-      backup_folder: backup_folder,
-      date_format: date_format,
-      version_prefix: version_prefix,
-      zip_prefix: zip_prefix,
-      max_versions: max_versions,
-      per_page: per_page
-    }
-  end
-
-  # Set configuration settings
-  #
-  # +options+ is a *hash* with the following keys backup_folder, date_format, version_prefix, zip_prefix, max_versions, per_page
-  def config= options
-    if options[:date_format].present?
-      # fall-back if the date_format is invalid
-      begin
-        Time.now.strftime(options[:date_format]).to_datetime
-      rescue
-        raise ArgumentError, "invalid date format"
-      end
-    end
-
-    options.slice(*config.keys).each do |k, v|
-      instance_variable_set "@#{k}", ([:max_versions, :per_page].include?(k) ? v.to_i : v.to_s)
-    end
-  end
-
-  # Returns a *string* of the folder that is used to keep the backup files and temporary files
-  def backup_folder
-    this_backup_folder = @backup_folder || "db/backup"
-
-    # the backup_folder will not have any slash at the end
-    this_backup_folder = this_backup_folder.to_s[0..-2] if this_backup_folder.to_s.last == "/"
-
-    # create the folder if doesn't exist
-    FileUtils.mkdir(this_backup_folder) unless File.directory?(this_backup_folder)
-
-    return this_backup_folder
-  end
-
-  # Returns a *string* of the date format that will be appended and used to time-stamp the backup files. Can be any valid date format similar with the ISO C and POSIX directives
-  #
-  # *Default* *value*: %d-%m-%Y_%H:%M
-  def date_format
-    @date_format || "%d-%m-%Y_%H:%M"
-  end
+require 'configure'
+require 'version'
 
-  # Returns a *string* of the prefix used to name each .diff file that contains changes from the last version. Automatically generated +version_number+ will be appended to the +version_prefix+
-  #
-  # *Default* *value*: +ver_+
-  def version_prefix
-    @version_prefix || "ver_"
-  end
-
-  # Returns a *string* of the prefix used to name the starting .zip file that contains a schema.rb file and a .csv file for each non-empty table
-  #
-  # *Default* *value*: +origin+
-  def zip_prefix
-    @zip_prefix || "origin"
-  end
-
-  # Returns an *integer* of maximum number of versions that can exist. If this number is exceeded, the first .diff version is merged in the starting .zip file and cannot be reversed
-  #
-  # *Default* *value*: +32+ (if backup is done daily, keep the last month versions)
-  def max_versions
-    @max_versions || 32
-  end
-
-  # Returns an *integer* of maximum number of rows fetched by a single query to avoid memory crashes. If your table has more rows it will be used multiple query to fetch all the data
-  #
-  # *Default* *value*: +100000+
-  def per_page
-    @per_page || 100000
-  end
+module TinyBackup
 
-  # Create a backup of the current database and choose automatically to create a .zip or .diff file
-  #
-  # *Lock* *until* *is* *done*
+  # Create a backup of the current database and choose automatically to create a .zip or .diff file.
   def backup_now
     # if the resource is locked, we skip to ensure block
     lock
     locked_by_this_method = true
 
-    @tmp_files = []
+    tmp_files = []
     nvf = new_version_filename
 
     stream = StringIO.new
@@ -109,21 +31,19 @@ module TinyBackup
     if nvf.split(".").last == "zip"
       # there is no .zip file so we must create one and add schema.rb and .csv file for each table
       # TODO: use a much better compression like Zlib::BEST_COMPRESSION to reduce the zip size, but this will consume processing power
-      ZIPLIB.open("#{backup_folder}/#{nvf}", ZIPLIB::CREATE) do |f|
-        puts "-- backup_schema\n"
+      ZIPLIB.open("#{config.backup_folder}/#{nvf}", ZIPLIB::CREATE) do |f|
         t_benchmark = Benchmark.ms do
           f.get_output_stream("schema.rb") do |ff|
             ff.write schema_rb
-            @tmp_files << ff if ZIPOLD
+            tmp_files << ff if ZIPOLD
           end
         end
-        puts "   -> #{'%.4f' % (t_benchmark/1000)}s\n"
+        puts "-- backup_schema\n   -> #{'%.4f' % (t_benchmark/1000)}s\n" if !config.silent
 
         ActiveRecord::Base.connection.tables.each do |table|
           next if table == "schema_migrations"
           query_count = ActiveRecord::Base.connection.execute("SELECT COUNT(*) FROM #{table}").first.first
 
-          puts "-- backup_table(\"#{table}\")\n"
           t_benchmark = Benchmark.ms do
             if query_count > 0
               rows = []
@@ -131,34 +51,33 @@ module TinyBackup
 
               loop do
                 break if query_index >= query_count
-                query = ActiveRecord::Base.connection.execute("SELECT * FROM #{table} LIMIT #{per_page} OFFSET #{query_index}")
+                query = ActiveRecord::Base.connection.execute("SELECT * FROM #{table} LIMIT #{config.per_page} OFFSET #{query_index}")
                 rows << add_query(query.fields) if query_index == 0
                 query.each { |row| rows << add_query(row) }
-                query_index += per_page
+                query_index += config.per_page
               end
 
               f.get_output_stream("#{table}.csv") do |ff|
                 ff.write rows.join
-                @tmp_files << ff if ZIPOLD
+                tmp_files << ff if ZIPOLD
               end
             end
           end
-          puts "   -> #{'%.4f' % (t_benchmark/1000)}s\n"
+          puts "-- backup_table(\"#{table}\")\n   -> #{'%.4f' % (t_benchmark/1000)}s\n" if !config.silent
         end
       end
 
     else
       # a new .diff file is created with the diff between origin_zip and tmp_origin_zip(made by merging all the versions into origin)
-      tmp_origin_zip = "#{backup_folder}/#{compact_original(:all)}"
+      tmp_origin_zip = "#{config.backup_folder}/#{compact_original(:all)}"
       tables = ActiveRecord::Base.connection.tables
       is_empty = true
 
-      File.open("#{backup_folder}/#{nvf}", "wb") do |f|
+      File.open("#{config.backup_folder}/#{nvf}", "wb") do |f|
         ZIPLIB.open(tmp_origin_zip) do |zf|
           zf.entries.each do |zf_entry|
 
             if zf_entry.name == "schema.rb"
-              puts "-- backup_schema\n"
               t_benchmark = Benchmark.ms do
                 tables.delete "schema_migrations"
                 this_diff = diff_files zf.read(zf_entry.name), schema_rb
@@ -172,7 +91,7 @@ module TinyBackup
                   f.write "\n\n"
                 end
               end
-              puts "   -> #{'%.4f' % (t_benchmark/1000)}s\n"
+              puts "-- backup_schema\n   -> #{'%.4f' % (t_benchmark/1000)}s\n" if !config.silent
             else
 
               table = zf_entry.name.split(".").first
@@ -186,14 +105,13 @@ module TinyBackup
               rows = []
               query_index = 0
 
-              puts "-- backup_table(\"#{table}\")\n"
               t_benchmark = Benchmark.ms do
                 loop do
                   break if query_index >= query_count
-                  query = ActiveRecord::Base.connection.execute("SELECT * FROM #{table} LIMIT #{per_page} OFFSET #{query_index}")
+                  query = ActiveRecord::Base.connection.execute("SELECT * FROM #{table} LIMIT #{config.per_page} OFFSET #{query_index}")
                   rows << add_query(query.fields) if query_index == 0
                   query.each { |row| rows << add_query(row) }
-                  query_index += per_page
+                  query_index += config.per_page
                 end
 
                 this_diff = diff_files zf.read(zf_entry.name), rows.join
@@ -207,7 +125,7 @@ module TinyBackup
                   f.write "\n\n"
                 end
               end
-              puts "   -> #{'%.4f' % (t_benchmark/1000)}s\n"
+              puts "-- backup_table(\"#{table}\")\n   -> #{'%.4f' % (t_benchmark/1000)}s\n" if !config.silent
             end
 
           end
@@ -224,15 +142,14 @@ module TinyBackup
           rows = []
           query_index = 0
 
-          puts "-- backup_table(\"#{table}\")\n"
           t_benchmark = Benchmark.ms do
             loop do
               break if query_index >= query_count
-              query = ActiveRecord::Base.connection.execute("SELECT * FROM #{table} LIMIT #{per_page} OFFSET #{query_index}")
+              query = ActiveRecord::Base.connection.execute("SELECT * FROM #{table} LIMIT #{config.per_page} OFFSET #{query_index}")
 
               rows << add_query(query.fields) if query_index == 0
               query.each { |row| rows << add_query(row) }
-              query_index += per_page
+              query_index += config.per_page
             end
 
             this_diff = diff_files "", rows.join
@@ -246,22 +163,22 @@ module TinyBackup
               f.write "\n\n"
             end
           end
-          puts "   -> #{'%.4f' % (t_benchmark/1000)}s\n"
+          puts "-- backup_table(\"#{table}\")\n   -> #{'%.4f' % (t_benchmark/1000)}s\n" if !config.silent
         end
       end
 
       File.delete tmp_origin_zip
-      File.delete("#{backup_folder}/#{nvf}") if is_empty
+      File.delete("#{config.backup_folder}/#{nvf}") if is_empty
     end
 
     # keep max versions
-    version_files = Dir.glob("#{backup_folder}/#{version_prefix}*").sort
-    if max_versions < version_files.length
+    version_files = Dir.glob("#{config.backup_folder}/#{config.version_prefix}*").sort
+    if config.max_versions < version_files.length
       # throw files to garbage
-      @tmp_files << Dir.glob("#{backup_folder}/#{zip_prefix}*").first
-      @tmp_files << version_files.first
+      tmp_files << Dir.glob("#{config.backup_folder}/#{config.zip_prefix}*").first
+      tmp_files << version_files.first
 
-      File.rename "#{backup_folder}/#{compact_original(1)}", dup_file("#{backup_folder}/#{zip_prefix}_#{Time.now.strftime(date_format)}.zip")
+      File.rename "#{config.backup_folder}/#{compact_original(1)}", dup_file("#{config.backup_folder}/#{config.zip_prefix}_#{Time.now.strftime(config.date_format)}.zip")
     end
 
     # delete temporary files before method exit
@@ -269,62 +186,62 @@ module TinyBackup
       @method_error = e
     ensure
       unlock if locked_by_this_method
-      @tmp_files.each { |i| File.delete(i) rescue nil } if @tmp_files.present?
+      tmp_files.each { |i| File.delete(i) rescue nil } if tmp_files.present?
       raise @method_error if @method_error.present?
       return true
   end
 
-  # Merge into the .zip file and delete all the .diff files to clear the space
-  #
-  # *Lock* *until* *is* *done*
+  # Merge into the .zip file and delete all the .diff files to clear the space.
   def compact_all
     lock # if the resource is locked, we skip to ensure block
     locked_by_this_method = true
 
-    @tmp_files = []
-    @tmp_files += Dir.glob("#{backup_folder}/#{zip_prefix}*")
-    @tmp_files += Dir.glob("#{backup_folder}/#{version_prefix}*")
+    tmp_files = []
+    tmp_files += Dir.glob("#{config.backup_folder}/#{config.zip_prefix}*")
+    tmp_files += Dir.glob("#{config.backup_folder}/#{config.version_prefix}*")
 
     # make the temporary zip be the original and apply the updated_at time-stamp
-    File.rename "#{backup_folder}/#{compact_original(:all)}", dup_file("#{backup_folder}/#{zip_prefix}_#{Time.now.strftime(date_format)}.zip")
+    File.rename "#{config.backup_folder}/#{compact_original(:all)}", dup_file("#{config.backup_folder}/#{config.zip_prefix}_#{Time.now.strftime(config.date_format)}.zip")
 
     # delete temporary files before method exit
     rescue => e
       @method_error = e
     ensure
       unlock if locked_by_this_method
-      @tmp_files.each { |i| File.delete(i) rescue nil } if @tmp_files.present?
+      tmp_files.each { |i| File.delete(i) rescue nil } if tmp_files.present?
       raise @method_error if @method_error.present?
       return true
   end
 
   # Change the database to match the selected integer +version_number+.
-  # If the +just_temporary+ is false, the unused version files will be deleted and the latest backup version will be synchronized with the database data.
-  # It's dangerous to start a new backup if the database is not synchronized with the latest backup version(call restore_db(:all) to restore all data)
-  #
-  # *Lock* *until* *is* *done*
-  def restore_db version_number, just_temporary=true
+  # @param version_number [Integer or Symbol] can be :all to restore all backup data or 0 to restore only the data collected in the .zip file
+  # @param just_temporary [Boolean] if is false, the unused version files will be deleted and the latest backup version will be synchronized with the database data.
+  # @param with_backup [Boolean] if is false, the attempt to backup not saved data is canceled
+  def restore_db version_number, just_temporary=true, with_backup=true
+    # do this before deleting the database and lose data
+    backup_now if just_temporary && with_backup
+
     lock # if the resource is locked, we skip to ensure block
     locked_by_this_method = true
 
-    @tmp_files = []
+    tmp_files = []
 
     if just_temporary && version_number != :all
-      puts "you want to restore just temporary: DO NOT start a backup BEFORE calling TinyBackup.restore_db(:all)\n"
+      puts "you want to restore just temporary: DO NOT start a backup BEFORE calling TinyBackup.restore_db(:all)\n" if !config.silent
     end
 
-    version_files = Dir.glob("#{backup_folder}/#{version_prefix}*")
+    version_files = Dir.glob("#{config.backup_folder}/#{config.version_prefix}*")
     if version_number == :all
       version_count = version_files.length
     else
-      good_versions = version_files.find_all { |i| i.gsub("#{backup_folder}/#{version_prefix}", "").split("_").first.to_i <= version_number.to_i }
+      good_versions = version_files.find_all { |i| i.gsub("#{config.backup_folder}/#{config.version_prefix}", "").split("_").first.to_i <= version_number.to_i }
       version_count = good_versions.length
-      @tmp_files += version_files - good_versions if !just_temporary
+      tmp_files += version_files - good_versions if !just_temporary
     end
 
     tmp_origin_zip = compact_original version_count
-    @tmp_files << "#{backup_folder}/#{tmp_origin_zip}"
-    @tmp_files << "#{backup_folder}/schema_tmp.rb"
+    tmp_files << "#{config.backup_folder}/#{tmp_origin_zip}"
+    tmp_files << "#{config.backup_folder}/schema_tmp.rb"
 
     db_name = Rails.configuration.database_configuration[Rails.env]["database"]
     db_collation = ActiveRecord::Base.connection.collation
@@ -333,31 +250,33 @@ module TinyBackup
     ActiveRecord::Base.connection.reconnect!
 
     # prepare the structure
-    ZIPLIB.open("#{backup_folder}/#{tmp_origin_zip}") do |zf|
+    ZIPLIB.open("#{config.backup_folder}/#{tmp_origin_zip}") do |zf|
       zf.entries.each do |zf_entry|
         if zf_entry.name == "schema.rb"
-          File.open("#{backup_folder}/schema_tmp.rb", "wb") { |f| f.write zf.read(zf_entry.name) }
+          File.open("#{config.backup_folder}/schema_tmp.rb", "wb") { |f| f.write zf.read(zf_entry.name) }
           break
         end
       end
     end
-    ActiveRecord::Schema.load("#{backup_folder}/schema_tmp.rb")
+    schema_verbose = ActiveRecord::Schema.verbose
+    ActiveRecord::Schema.verbose = !config.silent
+    ActiveRecord::Schema.load("#{config.backup_folder}/schema_tmp.rb")
+    ActiveRecord::Schema.verbose = schema_verbose
 
     # add the data
-    ZIPLIB.open("#{backup_folder}/#{tmp_origin_zip}") do |zf|
+    ZIPLIB.open("#{config.backup_folder}/#{tmp_origin_zip}") do |zf|
       zf.entries.each do |zf_entry|
         next if zf_entry.name == "schema.rb"
         table_rows = zf.read(zf_entry.name).split("\n")
         table_header = table_rows.shift
         table_name = zf_entry.name.split(".").first
 
-        puts "-- insert_data(\"#{table_name}\")\n"
         t_benchmark = Benchmark.ms do
-          table_rows.in_groups_of(per_page, false) do |tr_group|
+          table_rows.in_groups_of(config.per_page, false) do |tr_group|
             ActiveRecord::Base.connection.execute insert_row(table_name, table_header, tr_group)
           end
         end
-        puts "   -> #{'%.4f' % (t_benchmark/1000)}s\n"
+        puts "-- insert_data(\"#{table_name}\")\n   -> #{'%.4f' % (t_benchmark/1000)}s\n" if !config.silent
       end
     end
 
@@ -366,7 +285,7 @@ module TinyBackup
       @method_error = e
     ensure
       unlock if locked_by_this_method
-      @tmp_files.each { |i| File.delete(i) rescue nil } if @tmp_files.present?
+      tmp_files.each { |i| File.delete(i) rescue nil } if tmp_files.present?
       raise @method_error if @method_error.present?
       return true
   end
@@ -374,20 +293,24 @@ module TinyBackup
   # YOU SHALL NOT PASS -----------------------------------------------------------------
   private
 
-  # Returns a *string* of the query used to insert a row of data
+  # Create an SQL INSERT query.
+  # @param table_name [String]
+  # @param table_header [String] contains column names delimited by " and separated by , (like '"col1", "col2", "col3"')
+  # @param table_rows [Array] each row is a *String* with the same format as table_header
+  # @return [String] the query used to insert a row of data
   def insert_row(table_name, table_header, table_rows)
     "INSERT INTO #{table_name} (#{table_header.gsub("\"", "`")}) VALUES " +
       table_rows.map { |i| "(#{i})" }.join(",")
   end
 
-  # Merge X versions starting with the lowest +version_number+ into a temporary .zip file that looks like the original zip
-  #
-  # Returns a *string* that is the path of the temporary zip file
+  # Merge X versions starting with the lowest +version_number+ into a temporary .zip file that looks like the original zip.
+  # @param versions [Integer or Symbol] can be :all to compact all the versions and delete all the .diff files
+  # @return [String] the path of the temporary zip file
   def compact_original versions
-    versions = Dir.glob("#{backup_folder}/*").length if versions == :all
-    @tmp_files_compact ||= []
-    tmp_filename = "tmp_#{zip_prefix}_#{Time.now.to_i}.zip"
-    origin_zip = Dir.glob("#{backup_folder}/#{zip_prefix}*").first
+    versions = Dir.glob("#{config.backup_folder}/*").length if versions == :all
+    tmp_files = []
+    tmp_filename = "tmp_#{config.zip_prefix}_#{Time.now.to_i}.zip"
+    origin_zip = Dir.glob("#{config.backup_folder}/#{config.zip_prefix}*").first
 
     # add all files from original zip to a big hash
     zip_files = {}
@@ -396,7 +319,7 @@ module TinyBackup
     end
 
     # modify the hash on every version
-    Dir.glob("#{backup_folder}/#{version_prefix}*").sort.first(versions).each do |version_file|
+    Dir.glob("#{config.backup_folder}/#{config.version_prefix}*").sort.first(versions).each do |version_file|
       diff_hash = prepare_diff version_file
 
       zip_files.each do |k, v|
@@ -422,20 +345,26 @@ module TinyBackup
     end
 
     # save the big hash
-    ZIPLIB.open("#{backup_folder}/#{tmp_filename}", ZIPLIB::CREATE) do |f|
+    ZIPLIB.open("#{config.backup_folder}/#{tmp_filename}", ZIPLIB::CREATE) do |f|
       zip_files.each do |k, v|
         f.get_output_stream(k) do |ff|
           ff.write v
-          @tmp_files_compact << ff if ZIPOLD
+          tmp_files << ff if ZIPOLD
         end if v != "\n"
       end
     end
 
-    @tmp_files_compact.each { |i| File.delete i } if ZIPOLD
-    tmp_filename
+    # delete temporary files before method exit
+    rescue => e
+      @method_error = e
+    ensure
+      tmp_files.each { |i| File.delete(i) rescue nil } if tmp_files.present?
+      raise @method_error if @method_error.present?
+      return tmp_filename
   end
 
-  # Returns a *hash* with of the parsed .diff file
+  # @param diff_path [String]
+  # @return [Hash] of the parsed .diff file where each key is a file to be changed and the value is an *Array* or *String* of the .diff file lines
   def prepare_diff diff_path
     diff_hash = {}
 
@@ -454,9 +383,10 @@ module TinyBackup
     diff_hash
   end
 
-  # It happens if there are two files with the same date(after using the date_format)
-  #
-  # Returns a *string* that will fix the duplicated filename issue by appending an index
+  # It happens if there are two files with the same date(after using the date_format).
+  # *Does* *not* *create* *a* *file!*
+  # @param filename [String]
+  # @return [String] a new filename that will fix the duplicated filename issue by appending an index
   def dup_file filename
     return filename unless File.exist? filename
     index = 1
@@ -469,7 +399,9 @@ module TinyBackup
     end
   end
 
-  # Returns a *string* of the updated file after applying the diff
+  # @param file [String] content of the original file
+  # @param diff_lines [Array] each item is a line *String* of the diff file
+  # @return [String] of the updated file after applying the diff
   def update_file file, diff_lines
     file = file.split "\n"
     current_operation = nil
@@ -524,14 +456,16 @@ module TinyBackup
     file.join("\n")  + "\n"
   end
 
-  # Returns a *pair* *of* *integer* of the range interval in the diff operation
+  # @param operation [String] operation as seen in the .diff file
+  # @param sign [String] one of these values "a", "c" or "d" meaning add, change or delete operation
+  # @return [Array] of two *Integer* values of the range interval in the diff operation
   def diff_operation operation, sign
     val1, val2 = operation.split sign
     return diff_range(val1), diff_range(val2)
   end
 
-
-  # Returns an *array* that contains the starting position of the change and how many operations it will take
+  # @param value [String] a single line number like "3" or a range of lines separated by , like "3,6"
+  # @return [Array] that contains the starting position of the change and how many operations it will take
   def diff_range value
     if value.include? ","
       l, r = value.split(",")
@@ -542,10 +476,11 @@ module TinyBackup
   end
 
   # Two temporary files will be created, but deleted shortly after the operation is finished
-  #
-  # Returns an *array* that contains lines of the diff between +file1+ and +file2+
+  # @param file1 [String] contents of the file
+  # @param file2 [String] contents of the file
+  # @eturn [Array] that contains lines of the diff between +file1+ and +file2+
   def diff_files file1, file2
-    diff_filename = "#{backup_folder}/diff"
+    diff_filename = "#{config.backup_folder}/diff"
 
     File.open("#{diff_filename}1", "wb") { |f| f.write file1 }
     File.open("#{diff_filename}2", "wb") { |f| f.write file2 }
@@ -560,21 +495,22 @@ module TinyBackup
     diff_lines
   end
 
-  # Returns a *string* of the current file created by backup_now function
+  # @return [String] of the current file created by backup_now function
   def new_version_filename
-    backup_folder_files =  Dir.glob("#{backup_folder}/*").map { |i| i.gsub("#{backup_folder}/", "") }
+    backup_folder_files =  Dir.glob("#{config.backup_folder}/*").map { |i| i.gsub("#{config.backup_folder}/", "") }
 
-    zip_file = backup_folder_files.find { |i| i.starts_with?(zip_prefix) && i.ends_with?("zip") }
-    return "#{zip_prefix}_#{Time.now.strftime(date_format)}.zip" if zip_file.nil?
+    zip_file = backup_folder_files.find { |i| i.starts_with?(config.zip_prefix) && i.ends_with?("zip") }
+    return "#{config.zip_prefix}_#{Time.now.strftime(config.date_format)}.zip" if zip_file.nil?
 
-    version_files = backup_folder_files.find_all { |i| i.starts_with?(version_prefix) && i.ends_with?("diff") }.sort
-    return "#{version_prefix}1_#{Time.now.strftime(date_format)}.diff" if version_files.blank?
+    version_files = backup_folder_files.find_all { |i| i.starts_with?(config.version_prefix) && i.ends_with?("diff") }.sort
+    return "#{config.version_prefix}1_#{Time.now.strftime(config.date_format)}.diff" if version_files.blank?
 
-    last_version = version_files.last.gsub(version_prefix, "").split("_").first.to_i
-    return "#{version_prefix}#{last_version + 1}_#{Time.now.strftime(date_format)}.diff"
+    last_version = version_files.last.gsub(config.version_prefix, "").split("_").first.to_i
+    return "#{config.version_prefix}#{last_version + 1}_#{Time.now.strftime(config.date_format)}.diff"
   end
 
-  # Returns a *string* of parsed csv row to be inserted into database
+  # @param values [Array] csv row
+  # @return [String] of parsed csv row to be inserted into database
   def add_query values
     values.map do |val|
       if val.nil?
@@ -594,10 +530,10 @@ module TinyBackup
     @logger = ActiveRecord::Base.logger
     ActiveRecord::Base.logger = nil
 
-    if File.exist?("#{backup_folder}/.lock")
-      raise "Another operation is running. More info you can find in the '#{backup_folder}/.lock' file"
+    if File.exist?("#{config.backup_folder}/.lock")
+      raise "Another operation is running. More info you can find in the '#{config.backup_folder}/.lock' file"
     else
-      File.open("#{backup_folder}/.lock", "wb") do |f|
+      File.open("#{config.backup_folder}/.lock", "wb") do |f|
         f.write caller.join("\n") + "\n"
       end
     end
@@ -607,7 +543,7 @@ module TinyBackup
   def unlock
     ActiveRecord::Base.logger = @logger
 
-    File.delete("#{backup_folder}/.lock") if File.exist?("#{backup_folder}/.lock")
+    File.delete("#{config.backup_folder}/.lock") if File.exist?("#{config.backup_folder}/.lock")
   end
 end
 include TinyBackup

data/lib/version.rb

@@ -0,0 +1,3 @@
+module TinyBackup
+  VERSION = '0.1.0'
+end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tiny_backup
 version: !ruby/object:Gem::Version
-  version: 0.0.0
-  prerelease: 
+  version: 0.1.0
 platform: ruby
 authors:
 - Razvan Pavel
@@ -18,30 +17,31 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/configure.rb
 - lib/tiny_backup.rb
+- lib/version.rb
 homepage: http://rubygems.org/gems/tiny_backup
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Backup your database on S3 or local, optimized for small disk space
 test_files: []