gembase 0.5.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b2075c49a96fb7cfb47f1b1dcc0ce4990426d34899dbe5a6fb4e26bb3d89624
-  data.tar.gz: 7fe0747e86e9a39a03ad3aaf437ff26eeccac21fbbb5965759bc5caa2f54c6ea
+  metadata.gz: fc21c6acc25e4f96ef0b7e5f94b18b689c16cfa27b75deedad20ce55815f6696
+  data.tar.gz: f79a22783d36cace7031a42ad71ebd322c1255fd1e95526f9f297f1fdd2f95a9
 SHA512:
-  metadata.gz: d318c786331cbfa72a0126dad32ae42197a62358ed1caaeee2ea7351ce41df3df366831f3ad67f7b5a2c45b2da05df8b0c94534875fa7b83ea56fda76892de52
-  data.tar.gz: e664207015a063c5d81c4721baf506e5ed737ebd579ab5baa8470f97dc7d9d112d7492ad8b8961c8df16b85b444fd6288fff5bf7ad07848bba16eadfbc2a80db
+  metadata.gz: 4894e0f8dc727e31d12c9812e44e93e7a133993def365b683f5b34d519ce0cdf22c831c478878cdc483ce35eb6dc332f1bdae130e4c4a4aa043c49a2165efc62
+  data.tar.gz: 8d40a370ae3103df17ed23439b746f273cdeff8b7f9f3c9dba4c9a4352d59e3dc240fd8851427bf8ea6df15e3b4145406a987d1f9401b235da5682223d1889a0

data/lib/main.rb

@@ -1,232 +1,648 @@
 #!usr/bin/env ruby
-# NTBBloodbath | Gembase - Ruby DataBase
+# NTBBloodbath | Gembase - Ruby YAML DataBase Manager
 
 require 'yaml'
 require 'fileutils'
+require 'colorize'
+
+require_relative 'services'
 
 # @author NTBBloodbath
 module Gembase
 
-  # Create a new DataBase file with the given name.
-  # name must be an String.
+  # @!method settings(db, protect_db, path)
+  #   Settings for your database manager
+  #   @param db [String] name of your DataBase file
+  #   @param protect_db [Boolean] protect your db. Crypt and more.
+  #   @param path [String] path to your database files
+  #
+  # @example Enable the db protection
+  #   settings('example' true, 'root')
+  #
+  # @example Changing to a custom path
+  #   settings('example, true, './res')
   #
-  # create_db("example") #=> "example.rudb"
-  def Gembase.create_db(name)
-    raise "name must be an String" until name.is_a?(String)
-    FileUtils.touch("#{name}.rudb")
+  # @note You must need to put "root" if you don't want to use custom directories instead of the root directory of your project.
+  # @note You must need to write a password in your terminal when you start the file if you protected your db. It'll be required to encrypt and decrypt your db, save this!.
+  # @note You must use this method at the beginning of your code for your db to work. Obligatory method.
+  #
+  # @since 1.0.0
+  def self.settings(db, protect_db, path)
+    begin
+      raise Errors::invalid_param('db', 'String', 'Gembase.settings') until db.is_a?(String)
+    rescue => e
+      e
+    end
+
+    begin
+      raise Errors::invalid_param('protect_db', 'Boolean', 'Gembase.settings') until protect_db.is_a?(Boolean)
+    rescue => e
+      e
+    end
+
+    begin
+      raise Errors::invalid_param('path', 'String', 'Gembase.settings') until path.is_a?(String)
+    rescue => e
+      e
+    end
+
+    @path = path
+    @protect_db = protect_db.to_s
+    if @protect_db == 'true'
+      system('clear')
+      Errors::no_dependency('package', 'figlet', '-c Logger')
+      puts(%x(figlet -c Logger).colorize(:red), '====================================================================================='.colorize(:light_black), "\n", ">> [SecurityEnabled] | Now you can remove, modify, encrypt and rename your db.".colorize(:light_red))
+    elsif @protect_db == 'false'
+      system('clear')
+      Errors::no_dependency('package', 'figlet', '-c Logger')
+      puts(%x(figlet -c Logger).colorize(:red), '====================================================================================='.colorize(:light_black))
+      puts "\n>> [SecurityBreach] | If you don't protect your db, it'll be vulnerable to hackers. \n    You must need to enable protection and use Gembase.encrypt".colorize(:light_red)
+    end
+  end
+
+  # @!method create_db(db)
+  #   Create a new DataBase file with the given name
+  #   @param db [String] the name for your DataBase file
+  #
+  # @example Create a DB called example
+  #   create_db('example') #=> 'example.rudb'
+  def self.create_db(db)
+    begin
+      raise Errors::invalid_param('db', 'String', 'Gembase.create_db') until db.is_a?(String)
+    rescue => e
+      e
+    end
+
+    if @path.eql?('root')
+      @dbf = %x(find #{db}.erudb 2>/dev/null | wc -l).to_i # Identify if there's an encrypted db file
+    else
+      @dbf = %x(find #{@path}/#{db}.erudb 2>/dev/null | wc -l).to_i
+    end
+
+    if @dbf == 0
+      if @path.eql?('root')
+        FileUtils.touch("#{db}.rudb")
+      else
+        FileUtils.touch("#{@path}/#{db}.rudb")
+      end
+    end
   end
 
-  # Create a new Category inside our DataBase
-  # db must be an String.
-  # category must be an String.
+  # @!method create_category(db, category)
+  #   Create a new Category inside our DataBase
+  #   @param db [String] the name of your DataBase file
+  #   @param category [String] the name of your category
   #
-  # create_category("example", "foo")
-  def Gembase.create_category(db, category)
-    raise "db must be an String" until db.is_a?(String)
-    raise "category must be an String" until category.is_a?(String)
+  # @example Creating the users category
+  #   create_category('example', 'users')
+  def self.create_category(db, category)
+    begin
+      raise Errors::invalid_param('db', 'String', 'Gembase.create_category') until db.is_a?(String)
+    rescue => e
+      e
+    end
+
+    begin
+      raise Errors::invalid_param('category', 'String', 'Gembase.create_category') until category.is_a?(String)
+    rescue => e
+      e
+    end
 
     category_name = {
-      "#{category}" => {}
+      category.to_s => {}
     }
 
-    File.open("#{db}.rudb", "a+") do |f|
-      f.write(category_name.to_yaml)
+    if @dbf == 0
+      if @path.eql?('root')
+        File.open("#{db}.rudb", 'a+') do |f|
+          f.write(category_name.to_yaml)
+        end
+      else
+        File.open("#{@path}/#{db}.rudb", 'a+') do |f|
+          f.write(category_name.to_yaml)
+        end
+      end
     end
   end
 
-  # Create a new nested category
-  # db must be an String.
-  # parent_category must be an String.
-  # nested_category must be an String.
+  # @!method nested_category(db, parent_category, nested_category)
+  #   Create a new nested category
+  #   @param db [String] the nme of your DataBase file
+  #   @param parent_category [String] the name of your parent category
+  #   @param nested_category [String] the name of the nested category
+  #
+  # @example Creating a premium nested category
+  #   nested_category('example', 'users', 'premium')
   #
-  # nested_category("example", "foo", "bar")
-  def Gembase.nested_category(db, parent_category, nested_category)
-    raise "db must be an String" until db.is_a?(String)
-    raise "parent_category must be an String" until parent_category.is_a?(String)
-    raise "nested_category must be an String" until nested_category.is_a?(String)
+  # @since 0.5.0
+  def self.nested_category(db, parent_category, nested_category)
+    begin
+      raise Errors::invalid_param('db', 'String', 'Gembase.nested_category') until db.is_a?(String)
+    rescue => e
+      e
+    end
+
+    begin
+      raise Errors::invalid_param('parent_category', 'String', 'Gembase.nested_category') until parent_category.is_a?(String)
+    rescue => e
+        e
+    end
+
+    begin
+      raise Errors::invalid_param('nested_category', 'String', 'Gembase.nested_category') until nested_category.is_a?(String)
+    rescue => e
+      e
+    end
 
-    @database = File.open("#{db}.rudb")
-    @data = YAML.load(@database)
-    @data["#{parent_category}"].store("#{nested_category}", "{}")
-    @save = File.write(@database, @data.to_yaml)
+    if @dbf == 0
+      if @path.eql?('root')
+        @@database = File.open("#{db}.rudb")
+      else
+        @@database = File.open("#{@path}/#{db}.rudb")
+      end
+  
+      @@data = YAML.load(@@database)
+      @@data[parent_category.to_s].store(nested_category.to_s, {})
+      File.write(@@database, @@data.to_yaml)
+    end
   end
 
-  # Create an object inside a category
-  # db must be an String.
-  # category must be an String.
-  # key must be an String.
-  # value can be String, Integer or Boolean.
+  # @!method add_object(db, category, key, value)
+  #   Create an object inside a category
+  #   @param db [String] the name of your DataBase file
+  #   @param category [String] the name of your category
+  #   @param key [String] the key name of your object
+  #   @param value [String, Integer, Boolean] the value of your key
   #
-  # add_object("example", "users", "bloodbath", "premium")
+  # @example Add object 'bloodbath' with value 'premium'
+  #   add_object('example', 'users', 'bloodbath', 'premium')
   #
-  # [DEPRECATED] Use create_object Method instead.
-  def Gembase.add_object(db, category, key, value)
-    raise "db must be an String" until db.is_a?(String)
-    raise "category must be an String" until category.is_a?(String)
-    raise "key must be an String" until key.is_a?(String)
+  # @deprecated Use {#create_object} instead.
+  def self.add_object(db, category, key, value)
+    begin
+      raise Errors::invalid_param('db', 'String', 'Gembase.add_object') until db.is_a?(String)
+    rescue => e
+      e
+    end
 
-    puts "WARNING | add_object Method is deprecated. Please use create_object Method instead."
-    @database
-    @data
-    @data["#{category}"].store("#{key}", "#{value}")
+    begin
+      raise Errors::invalid_param('category', 'String', 'Gembase.add_object') until category.is_a?(String)
+    rescue => e
+      e
+    end
+    
+    begin
+      raise Errors::invalid_param('key', 'String', 'Gembase.add_object') until key.is_a?(String)
+    rescue => e
+      e
+    end
+
+    puts "\n>> [WARNING] | add_object Method is deprecated. Please use create_object Method instead.".colorize(:red)
+    if @dbf == 0
+      @@database
+      @@data
+      @@data[category.to_s].store(key.to_s, value)
+    end
   end
   
-  # Create an object outside a category
-  # db must be an String.
-  # key must be an String.
-  # value can be String, Integer or Boolean.
-  # category must be an String.
-  # subcategory must be an String.
-  #
-  # Create object "server" with value "localhost:8080". Without categories.
-  #   create_object("example", "server", "localhost:8080")
-  #
-  # Create object "users-limit" with value 5 in "users" category.
-  #   create_object("example", "users-limit", 5, "users")
-  #
-  # Create object "bloodbath" with value true in "premium" subcategory.
-  #   create_object("example", "bloodbath", true, "users", "premium")
-  def Gembase.create_object(db, key, value, category=nil, subcategory=nil)
-	raise "db must be an String" until db.is_a?(String)
-	raise "key must be an String" until key.is_a?(String)
+  # @!method create_object(db, key, value, category=nil, subcategory=nil)
+  #   Create an object outside a category
+  #   @param db [String] the name of your DataBase file
+  #   @param key [String] the key name of your object
+  #   @param value [String, Integer, Boolean] the value of your key
+  #   @param category [String] the name of your category
+  #   @param subcategory [String] the name of your subcategory
+  #
+  # @example Create object 'server' with value 'localhost:8080'. Without categories.
+  #   create_object('example', 'server', 'localhost:8080')
+  #
+  # @example Create object 'users-limit' with value 5 in 'users' category.
+  #   create_object('example', 'users-limit', 5, 'users')
+  #
+  # @example Create object 'bloodbath' with value true in 'premium' subcategory.
+  #   create_object('example', 'bloodbath', true, 'users', 'premium')
+  def self.create_object(db, key, value, category=nil, subcategory=nil)
+    begin
+      raise Errors::invalid_param('db', 'String', 'Gembase.create_object') until db.is_a?(String)
+    rescue => e
+      e
+    end
+
+    begin
+      raise Errors::invalid_param('key', 'String', 'Gembase.create_object') until key.is_a?(String)
+    rescue => e
+      e
+    end
     
-    if category.to_s.length == 0
-      @database
-      @data
-      @data.store("#{key}", "#{value}")
-      @save
-    else
-      raise "category must be an String" until category.is_a?(String)
-      if subcategory.to_s.length == 0
-        @database
-        @data
-        @data["#{category}"].store("#{key}", "#{value}")
-        @save
+    if @dbf == 0
+      if category.to_s.length.zero?
+        @@database
+        @@data
+        @@data.store(key.to_s, value)
+        File.write(@@database, @@data.to_yaml)
       else
-        raise "subcategory must be an String" until subcategory.is_a?(String)
-        @database
-        @data
-        @data["#{category}"]["#{subcategory}"].store("#{key}", "#{value}")
-        @save
+        begin
+          raise Errors::invalid_param('category', 'String', 'Gembase.create_object') until category.is_a?(String)
+        rescue => e
+          e
+        end
+        if subcategory.to_s.length.zero?
+          @@database
+          @@data
+          @@data
+          @@data[category.to_s].store(key.to_s, value)
+          File.write(@@database, @@data.to_yaml)
+        else
+          begin
+            raise Errors::invalid_param('subcategory', 'String', 'Gembase.create_object') until subcategory.is_a?(String)
+          rescue => e
+            e
+          end
+          @@database
+          @@data
+          @@data[category.to_s][subcategory.to_s].store(key.to_s, value)
+          File.write(@@database, @@data.to_yaml)
+        end
       end
     end
   end
 
   # @!method delete_object(db, key, category=nil, subcategory=nil)
-  #   Delete an object inside/outside a category and subcategory.
-  # db must be an String.
-  # key must be an String.
-  # category must be an String.
-  # subcategory must be an String.
-  #
-  # Deleting object inside a category
-  #   delete_object("example", "users-limit", "users")
-  #
-  # Deleting object inside a subcategory
-  #   delete_object("example", "bloodbath", "users", "premium")
-  #
-  # Deleting object outside a category
-  #   delete_object("example", "server")
-  #
-  # Note: Category and subcategory are an optional parameters. Use them only when you want to delete an object inside a category or subcategory.
-  def Gembase.delete_object(db, key, category=nil, subcategory=nil)
-    raise "db must be an String" until db.is_a?(String)
-    raise "key must be an String" until key.is_a?(String)
-
-    if category.to_s.length == 0
-      @database
-      @data
-      @data.delete("#{key}")
-      File.open("#{db}.rudb", "w+") do |f|
-        f.write(@data.to_yaml)
-      end
-    else
-      if subcategory.to_s.length == 0
-        raise "category must be an String" until category.is_a?(String)
-        @database
-        @data
-        @data["#{category}"].delete("#{key}")
-        File.open("#{db}.rudb", "w+") do |f|
-          f.write(@data.to_yaml)
+  #   Delete an object inside/outside a category.
+  #   @param db [String] the name of your DataBase file
+  #   @param key [String] the key name of your object
+  #   @param category [String] the name of your category
+  #   @param subcategory [String] the name of your subcategory
+  #
+  # @example Deleting object inside a category
+  #   delete_object('example', 'users-limit', 'users')
+  #
+  # @example Deleting object inside a subcategory
+  #   delete_object('example', 'bloodbath', 'users', 'premium')
+  #
+  # @example Deleting object outside a category
+  #   delete_object('example', 'server')
+  #
+  # @note Category is an optional parameter. Use this only when you want to delete an object inside a category.
+  def self.delete_object(db, key, category=nil, subcategory=nil)
+    begin
+      raise Errors::invalid_param('db', 'String', 'Gembase.delete_object') until db.is_a?(String)
+    rescue => e
+      e
+    end
+
+    begin
+      raise Errors::invalid_param('key', 'String', 'Gembase.delete_object') until key.is_a?(String)
+    rescue => e
+      e
+    end
+
+    if @dbf == 0
+      if category.to_s.length.zero?
+        @@database
+        @@data
+        @@data.delete(key.to_s)
+        if @path.eql?('root')
+          File.open("#{db}.rudb", 'w+') do |f|
+            f.write(@@data.to_yaml)
+          end
+        else
+          File.open("#{@path}/#{db}.rudb", 'w+') do |f|
+            f.write(@@data.to_yaml)
+          end
         end
       else
-        raise "subcategory must be an String" until subcategory.is_a?(String)
-        @database
-        @data
-        @data["#{category}"]["#{subcategory}"].delete("#{key}")
-        File.open("#{db}.rudb", "w+") do |f|
-          f.write(@data.to_yaml)
+        if subcategory.to_s.length.zero?
+          begin
+            raise Errors::invalid_param('category', 'String', 'Gembase.delete_object') until category.is_a?(String)
+          rescue => e
+            e
+          end
+          @@database
+          @@data
+          @@data[category.to_s].delete(key.to_s)
+          File.open("#{db}.rudb", 'w+') do |f|
+            f.write(@@data.to_yaml)
+          end
+        else
+          begin
+            raise Errors::invalid_param('subcategory', 'String', 'Gembase.delete_object') until subcategory.is_a?(String)
+          rescue => e
+            e
+          end
+          @@database
+          @@data
+          @@data[category.to_s][subcategory.to_s].delete(key.to_s)
+          if @path.eql?('root')
+            File.open("#{db}.rudb", 'w+') do |f|
+              f.write(@@data.to_yaml)
+            end
+          else
+            File.open("#{@path}/#{db}.rudb", 'w+') do |f|
+              f.write(@@data.to_yaml)
+            end
+          end
         end
       end
     end
   end
 
-  # Change the value of an existing object
-  # db must be an String.
-  # key must be an String.
-  # new_value can be String, Integer or Boolean.
-  # category must be an String.
-  # subcategory must be an String.
+  # @!method change_object(db, key, new_value, category=nil, subcategory=nil)
+  #   Change the value of an existing object
+  #   @param db [String] the name of your DataBase file
+  #   @param key [String] the key name of your object
+  #   @param new_value [String, Integer, Boolean] the new value of your key
+  #   @param category [String] the name of your category
+  #   @param  subcategory [String] the name of your subcategory
   #
-  # Change key server value from localhost:8080 to example_host.com outside categories
-  #   change_object("example", "server", "example_host.com")
+  # @example Change key server value from localhost:8080 to example_host.com outside categories
+  #   change_object('example', 'server', 'example_host.com')
   # 
-  # Change key users-limit value from 5 to 10 into users category
-  #   change_object("example", "users-limit", "10", "users")
-  #
-  # Change key bloodbath value from true to false into premium subcategory
-  #   change_object("example", "bloodbath", false, "users", "category")
-  #
-  # Note: Category and subcategory are an optional parameters. Use them only when you want to modify an object inside a category or subcategory.
-  def Gembase.change_object(db, key, new_value, category=nil, subcategory=nil)
-    raise "db must be an String" until db.is_a?(String)
-    raise "key must be an String" until key.is_a?(String)
-
-    if category.to_s.length == 0
-      @database
-      @data
-      @data["#{key}"] = new_value
-      @save
-    else
-      raise "category must be an String" until category.is_a?(String)
-      if subcategory.to_s.length == 0
-        @database
-        @data
-        @data["#{category}"]["#{key}"] = new_value
-        @save
+  # @example Change key users-limit value from 5 to 10 into users category
+  #   change_object('example', 'users-limit', '10', 'users')
+  #
+  # @example Change key bloodbath value from true to false into premium subcategory
+  #   change_object('example', 'bloodbath", false, 'users', 'category')
+  #
+  # @since 0.5.0
+  def self.change_object(db, key, new_value, category=nil, subcategory=nil)
+    begin
+      raise Errors::invalid_param('db', 'String', 'Gembase.change_object') until db.is_a?(String)
+    rescue => e
+      e
+    end
+
+    begin
+      raise Errors::invalid_param('key', 'String', 'Gembase.change_object') until key.is_a?(String)
+    rescue => e
+      e
+    end
+
+    if @dbf == 0
+      if category.to_s.length.zero?
+        @@database
+        @@data
+        @@data[key.to_s] = new_value
+        File.write(@@database, @@data.to_yaml)
       else
-        raise "subcategory must be an String" until subcategory.is_a?(String)
-        @database
-        @data
-        @data["#{category}"]["#{subcategory}"]["#{key}"] = new_value
-        @save
+        begin
+          raise Errors::invalid_param('category', 'String', 'Gembase.change_object') until category.is_a?(String)
+        rescue => e
+          e
+        end
+        if subcategory.to_s.length.zero?
+          @@database
+          @@data
+          @@data[category.to_s][key.to_s] = new_value
+          File.write(@@database, @@data.to_yaml)
+        else
+          begin
+            raise Errors::invalid_param('subcategory', 'String', 'Gembase.change_object') until subcategory.is_a?(String)
+          rescue => e
+            e
+          end
+          @@database
+          @@data
+          @@data[category.to_s][subcategory.to_s][key.to_s] = new_value
+          File.write(@@database, @@data.to_yaml)
+        end
       end
     end
   end
 
-  # Parse the Database structure to modify it
-  # db must be an String.
+  # @!method parse(db)
+  #   Parse the DataBase structure to modify it
+  #   @param db [String] the name of your DataBase file
+  #
+  # @example Parsing the DB called 'example'
+  #   parse('example')
+  #
+  # @note You can use these two methods (parse and generate) instead of YAML vanilla methods (load and to_yaml).
+  def self.parse(db)
+    begin
+      raise Errors::invalid_param('db', 'String', 'Gembase.parse') until db.is_a?(String)
+    rescue => e
+      e
+    end
+
+    if @dbf == 0
+      @@database
+      @@data
+    end
+  end
+
+  # @!method regenerate(db)
+  #   Regenerate the DataBase stucture to YAML structure
+  #   @param db [String] the name of your DataBase file
+  #
+  # @example Regenerating the DB called 'example'
+  #   regenerate('example')
+  def self.regenerate(db)
+    begin
+      raise Errors::invalid_param('db', 'String', 'Gembase.regenerate') until db.is_a?(String)
+    rescue => e
+      e
+    end
+
+    if @dbf == 0
+      @@database
+      @@data.to_yaml
+    end
+  end
+
+  # @!method encrypt_db(db)
+  #   Encrypt your database.
+  #   @param db [String] the name of your DataBase file
+  #
+  # @example Encrypting example db
+  #   encrypt_db('example') #=> example.erudb
   #
-  # Parsing the DB called "example"
-  #   parse("example")
+  # @note You'll need to establish a passphrase to encrypt/decrypt.
   #
-  # Note: You can use these two methods (parse and generate) instead of YAML vanilla methods (load and to_yaml).
-  def Gembase.parse(db)
-    raise "db must be an String" until db.is_a?(String)
+  # @since 1.0.0
+  def self.encrypt_db(db)
+    begin
+      raise Errors::invalid_param('db', 'String', 'Gembase.encrypt_db') until db.is_a?(String)
+    rescue => e
+      e
+    end
 
-    @database
-    @data
+    @encrypted = @dbf
+
+    if @protect_db.eql?('true')
+      if @encrypted == 0
+        puts("\n>> Encrypting your database...".colorize(:light_black), "\n>> Recomendations: set a secure password with more than 8 characters and save\n   it in a secure site".colorize(:light_black), "\n")
+        if @path.eql?('root')
+          Errors::no_dependency('gem', 'yaml_vault', "encrypt #{db}.rudb -o #{db}.erudb")
+          system("yaml_vault encrypt #{db}.rudb -o #{db}.erudb")
+          system("rm #{db}.rudb")
+        else
+          Errors::no_dependency('gem', 'yaml_vault', "encrypt #{@path}/#{db}.rudb -o #{@path}/#{db}.erudb")
+          system("yaml_vault encrypt #{@path}/#{db}.rudb -o #{@path}/#{db}.erudb")
+          system("rm #{@path}/#{db}.rudb")
+        end
+      elsif @encrypted != 0
+        puts("\n>> Your database #{db} is already encrypted. If you want to decrypt it\n   use decrypt_db method.".colorize(:light_black))
+      end
+    elsif @protect_db.eql?('false')
+      Errors::protected_db(db, 'encrypt')
+    end
   end
 
-  # Regenerate the Database stucture to YAML structure
-  # db must be an String.
+  # @!method decrypt_db(db)
+  #   Decrypt your database.
+  #   @param db [String] the name of your DataBase file
+  #
+  # @example Decrypting example db
+  #   decrypt_db('example')
+  #
+  # @note You'll need to decrypt your db to modify it.
   #
-  # Regenerating the DB called "example"
-  #   regenerate("example")
-  def Gembase.regenerate(db)
-    raise "db must be an String" until db.is_a?(String)
+  # @since 1.0.0
+  def self.decrypt_db(db)
+    begin
+      raise Errors::invalid_param('db', 'String', 'Gembase.decrypt_db') until db.is_a?(String)
+    rescue => e
+      e
+    end
+
+    if @encrypted != 0
+      puts "\n>> Decrypting your database...".colorize(:light_black)
+      if @path.eql('root')
+        Errors::no_dependency('gem', 'yaml_vault', "decrypt #{db}.erudb -o #{db}.rudb")
+        system("yaml_vault decrypt #{db}.erudb -o #{db}.rudb")
+      else
+        Errors::no_dependency('gem', 'yaml_vault', "decrypt #{db}.erudb -o #{db}.rudb")
+        system("yaml_vault encrypt #{@path}/#{db}.erudb -o #{@path}/#{db}.rudb")
+      end
+    elsif @encrypted == 0
+      puts('Your database isn\'t encrypted. If you want to encrypt it, use encrypt_db method.'.colorize(:light_black))
+    end
+  end
 
-    @database
-    @data.to_yaml
+  # @!method rename_db(old_name, new_name)
+  #   Rename your database file.
+  #   @param old_name [String] the old name of your DataBase file
+  #   @param new_name [String] the new name of your DataBase file
+  #
+  # @example Renaming the example database
+  #   rename_db('example', 'example-new')
+  #
+  # @since 1.0.0
+  def self.rename_db(old_name, new_name)
+    begin
+      raise Errors::invalid_param('old_name', 'String', 'Gembase.rename_db') until old_name.is_a?(String)
+    rescue => e
+      e
+    end
+
+    begin
+      raise Errors::invalid_param('new_name', 'String', 'Gembase.rename_db') until new_name.is_a?(String)
+    rescue => e
+      e
+    end
+
+    if %x(find "#{old_name}.rudb" | wc -l).to_i == 0
+      Errors::custom_error(">> [RuntimeError] | The database file #{old_name} doesn't exist or\n   has been already renamed.")
+    else
+      if @protect_db.eql?('true')
+        Errors::protected_db(old_name, 'rename')
+      elsif @protect_db.eql?('false')
+        if @path.eql?('root')
+          system("mv #{old_name}.rudb #{new_name}.rudb")
+        else
+          system("mv #{@path}/#{old_name}.rudb #{@path}/#{new_name}.rudb")
+        end
+      end
+    end
+  end
+
+  # @!method delete_db(db)
+  #   Delete your database file.
+  #   @param db [String] the name of your DataBase file
+  #
+  # @example Deleting example db
+  #   delete_rb('example')
+  #
+  # @since 1.0.0
+  def self.delete_db(db)
+    begin
+      raise Errors::invalid_param('db', 'String', 'Gembase.delete_db') until db.is_a?(String)
+    rescue => e
+      e
+    end
+
+    if @protect_db.eql?('true')
+      Errors::protected_db(db, 'delete')
+    elsif @protect_db.eql?('false')
+      if @path.eql?('root')
+        system("rm #{db}.rudb")
+      else
+        system("rm #{@path}/#{db}.rudb")
+      end
+    end
+  end
+
+  # @!method restart_db(db)
+  #   Restart your database file.
+  #   @param db [String] the name of your DataBase file
+  #
+  # @example Restarting example db
+  #   restart_db('example')
+  #
+  # @since 1.0.0
+  def self.restart_db(db)
+    begin
+      raise Errors::invalid_param('db', 'String', 'Gembase.delete_db') until db.is_a?(String)
+    rescue => e
+      e
+    end
+
+    if @protect_db.eql?('true')
+      Errors::protected_db(db, 'restart')
+    elsif @protect_db.eql?('false')
+      if @path.eql?('root')
+        system("rm #{db}.rudb")
+        system("touch #{db}.rudb")
+      else
+        system("rm #{@path}/#{db}.rudb")
+        system("touch #{@path}/#{db}.rudb")
+      end
+    end
+  end
+
+  # @!method working_db
+  #   Lists your working/active database files and display her names.
+  #
+  # @example List your working databases
+  #   working_db
+  #
+  # @note It only works in your terminal. That's an db monitor and doesn't affect your databases.
+  #   Warning: don't use this if you don't have any db file in your work directory to avoid errors.
+  #
+  # @since 1.0.0
+  def self.working_db
+    Errors::no_dependency('package', 'figlet', '-c Viewer')
+    puts("\n", '====================================================================================='.colorize(:light_black), "\n\n", %x(figlet -c Viewer).colorize(:red), '====================================================================================='.colorize(:light_black))
+    files = 'find . -wholename "*.rudb" && find . -wholename "*.erudb"'
+    count = 'find . -wholename "*.rudb" | wc -l && find . -wholename "*.erudb" | wc -l'
+    @working_file = %x(#{files}).sub("\n", ', ').delete_suffix("\n").sub(',', '')
+    @arr_files = Array(@working_file.split(' '))
+    @working_number = %x(#{count}).sub("\n", ', ').delete_suffix("\n").sub(',', '')
+    @arr_count = Array(@working_number.split(' '))
+    @working_numberf = @arr_count[0].to_i + @arr_count[1].to_i
+    puts "\n> Working databases: ".colorize(:light_red) + "#{@working_numberf.to_s.colorize(:light_black)}" + "\n  • Unencrypted databases: ".colorize(:light_red) + "#{@arr_count[0].colorize(:light_black)}" + "\n  • Encrypted databases: ".colorize(:light_red) + "#{@arr_count[1].colorize(:light_black)}\n\n"
+    @min = 0
+    @max = @working_numberf.to_i
+    loop do
+      @protected = @arr_files[@min].end_with?('.erudb')
+      puts "• #{@arr_files[@min].colorize(:light_black)} \n  Protected? #{@protected.to_s.colorize(:red)} \n  Size: #{%x(ls -sh #{@arr_files[@min]}).delete_suffix("\n").sub(' ', '').delete_suffix("#{@arr_files[@min]}").colorize(:red)} \n\n"
+      @min += 1
+      if @min >= @max
+        @min = 0
+        break
+      end
+    end
+    Services::closing
   end
 end

data/lib/services.rb

@@ -0,0 +1,202 @@
+#!usr/bin/env ruby
+# NTBBloodbath | Gembase - Ruby YAML DataBase Manager
+
+require 'colorize'
+require_relative 'main'
+
+# @author NTBBloodbath
+
+# Boolean Class for Ruby
+module Boolean; end
+
+class TrueClass
+  include Boolean
+end
+
+class FalseClass
+  include Boolean
+end
+
+class Errors < StandardError
+  attr_reader :dependency, :argument, :param, :type, :method, :db
+
+  def self.no_dependency(type, dependency, argument=nil)
+    begin
+      raise Errors.invalid_param('type', 'String', 'Errors.invalid_param') until type.is_a?(String)
+    rescue => e
+      e
+    end
+
+    begin
+      raise Errors.invalid_param('dependency', 'String', 'Errors.invalid_param') until dependency.is_a?(String)
+    rescue => e
+      e
+    end
+
+    if argument.to_s.length == 0
+      if !system("#{dependency}") then
+        puts "\n>> [RuntimeError] | The package #{dependency} isn't installed. \n   Do you want to install it? [y/n]".colorize(:light_red)
+        installation = gets.chomp
+
+        case installation
+        when "y"
+          if Dir.home == "/data/data/com.termux/files/home" # Termux installation
+            if type.eql?('package')
+              system("apt install #{dependency}")
+            elsif type.eql?('gem')
+              system("gem install #{dependency}")
+            end
+          else # Linux installation
+            if File.exist?("/usr/bin/apt-get") then # Debian-based OS
+              if type.eql?('package')
+                system("sudo apt-get install #{dependency}")
+              elsif type.eql?('gem')
+                system("sudo gem install #{dependency}")
+              end
+            elsif File.exist?("/usr/bin/pacman") then # Arch OS
+              if type.eql?('package')
+                system("sudo pacman -S #{dependency}")
+              elsif type.eql?('gem')
+                system("sudo gem install #{dependency}")
+              end
+            end
+          end
+        when "n"
+          puts "\n>> [RuntimeError] | You must install the dependencies so that the \n   administrator has a good functioning".colorize(:light_red)
+        end
+      end
+    else
+      begin
+        raise Errors.invalid_param('argument', 'String', 'Errors.invalid_param') until argument.is_a?(String)
+      rescue => e
+        e
+      end
+
+      if !system("#{dependency}", "#{argument}") then
+        puts "\n>> [RuntimeError] | The package #{dependency} isn't installed. \n   Do you want to install it? [y/n]".colorize(:light_red)
+        installation = gets.chomp
+
+        case installation
+        when "y"
+          if Dir.home == "/data/data/com.termux/files/home" # Termux installation
+            if type.eql?('package')
+              system("apt install #{dependency}")
+            elsif type.eql?('gem')
+              system("gem install #{dependency}")
+            end
+          else # Linux installation
+            if File.exist?("/usr/bin/apt-get") then # Debian-based OS
+              if type.eql?('package')
+                system("sudo apt-get install #{dependency}")
+              elsif type.eql?('gem')
+                system("sudo gem install #{dependency}")
+              end
+            elsif File.exist?("/usr/bin/pacman") then # Arch OS
+              if type.eql?('package')
+                system("sudo pacman -S #{dependency}")
+              elsif type.eql?('gem')
+                system("sudo gem install #{dependency}")
+              end
+            end
+          end
+        when "n"
+          puts "\n>> [RuntimeError] | You must install the dependencies so that the \n   administrator has a good functioning".colorize(:light_red)
+        end
+      end
+    end
+  end
+
+  def self.custom_error(message)
+    begin
+      raise Errors.invalid_param('message', 'String', 'Errors.custom_error') until message.is_a?(String)
+    rescue => e
+      e
+    end
+
+    puts("\n#{message}".colorize(:light_red))
+  end
+
+  def self.invalid_param(param, type, method)
+    begin
+      raise Errors.invalid_param('param', 'String', 'Errors.invalid_param') until param.is_a?(String)
+    rescue => e
+      e
+    end
+
+    begin
+      raise Errors.invalid_param('type', 'String', 'Errors.invalid_param') until type.is_a?(String)
+    rescue => e
+      e
+    end
+
+    begin
+      raise Errors.invalid_param('method', 'String', 'Errors.invalid_param') until method.is_a?(String)
+    rescue => e
+      e
+    end
+
+    case type
+    when 'String'
+      puts "\n>> [RuntimeError] | #{param} must be an String on #{method}! \n   Your code won't work properly. Please rewrite your code and restart it.".colorize(:light_red)
+    when 'Integer'
+      puts "\n>> [RuntimeError] | #{param} must be an Integer on #{method}! \n   Your code won't work properly. Please rewrite your code and restart it.".colorize(:light_red)
+    when 'Boolean'
+      puts "\n>> [RuntimeError] | #{param} must be an Boolean on #{method}! \n   Your code won't work properly. Please rewrite your code and restart it.".colorize(:light_red)
+    end
+  end
+
+  def self.protected_db(db, method)
+    begin
+      raise Errors.invalid_param('db', 'String', 'Errors.protected_db') until db.is_a?(String)
+    rescue => e
+      e
+    end
+
+    begin
+      raise Errors.invalid_param('method', 'String', 'Errors.protected_db') until method.is_a?(String)
+    rescue => e
+      e
+    end
+
+    case method
+    when 'rename'
+      puts "\n>> [SecurityError] | #{db}.rudb is protected! \n   If you want to rename it, you'll need to disable the Gembase protection.".colorize(:light_red)
+    when 'delete'
+      puts "\n>> [SecurityError] | #{db}.rudb is protected! \n   If you want to delete it, you'll need to disable the Gembase protection.".colorize(:light_red)
+    when 'restart'
+      puts "\n>> [SecurityError] | #{db}.rudb is protected! \n   If you want to restart it, you'll need to disable the Gembase protection.".colorize(:light_red)
+    when 'encrypt'
+      puts "\n>> [SecurityError] | #{db}.rudb isn't protected! \n   If you want to encrypt it, you'll need to enable the Gembase protection.".colorize(:light_red)
+    end
+  end
+end
+
+class Services
+  def self.closing
+    begin
+      puts("\n", '====================================================================================='.colorize(:light_black), "\n>> [Note] | Put exit to close the Manager and clear your screen".colorize(:light_red))
+      print ">> ".colorize(:light_black)
+      close = gets.chomp
+      puts ' '
+
+      if close.eql?('exit')
+        0.step(limit=100, step=20) do |i|
+          printf("\rClosing the Gembase Manager... ".colorize(:red) + "[%-20s]", "=" * (i/5))
+          %x(sleep 0.5)
+        end
+        %x(sleep 1)
+        system('clear')
+      else
+        puts "Unknown option, restarting the Viewer..."
+        %x(sleep 1)
+        system('clear')
+        %x(sleep 1)
+        Gembase.working_db
+      end
+    rescue Interrupt
+      puts 'Closing the Gembase Manager...'.colorize(:red)
+      %x(sleep 0.5)
+      system('clear')
+    end
+  end
+end

metadata

@@ -1,17 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: gembase
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 1.0.0
 platform: ruby
 authors:
 - NTB Bloodbath
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-08 00:00:00.000000000 Z
-dependencies: []
-description: Gembase is a database gem for Ruby. Very powerful, simple and effective
-  based on YAML.
+date: 2020-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: yaml_vault
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+description: Gembase is a YAML database manager gem for Ruby. Very powerful, simple
+  and effective.
 email:
 - bloodbathalchemist@protonmail.com
 executables: []
@@ -19,6 +59,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/main.rb
+- lib/services.rb
 homepage: https://rubygems.org/gems/gembase
 licenses:
 - MIT
@@ -43,5 +84,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: Gembase is a database gem based on YAML for Ruby.
+summary: Gembase is a YAML database manager gem for Ruby.
 test_files: []