module PadUtils
Main namespace for PadUtils
.
Each method is implemented as a module method. Prefix them with PadUtils
to call them. @example
PadUtils.some_method(param)
Constants
- VERSION
PadUtils
version number
Public Class Methods
Appends content to a file.
@note Will create the destination file if it doesn't exist.
It also prepends a newline character. Set new_line to false to change this.
Will log errors using {PadUtils.log PadUtils.log
}.
@param filepath [String] the file path and name @param content [String] the content to append @param new_line [Boolean] prepends a newline character @return [Void] nothing @example
PadUtils.append_to_file("path/to/file.txt", "Append this!", false)
# File lib/pad_utils/pad_files.rb, line 162 def self.append_to_file(filepath, content, new_line = true) self.create_directory(filepath) content = "\n#{content}" if new_line File.open(filepath, 'a') { |f| f.write("#{content}")} rescue Exception => e PadUtils.log("Error in append_to_file", e) end
Converts a string to a CamelCase.
@note The string will first be sanitized using {PadUtils.sanitize PadUtils.sanitize
}.
@param value [String] the string to CamelCase @return [String] the CamelCased string @example
s = "hello_you" s2 = "hello you" s3 = "hello $you#" PadUtils.convert_to_ruby_name(s) # => 'HelloYou' PadUtils.convert_to_ruby_name(s2) # => 'HelloYou' PadUtils.convert_to_ruby_name(s3) # => 'HelloYou'
# File lib/pad_utils/pad_text.rb, line 34 def self.camel_case(value) value = self.sanitize(value) if value.scan(/\_|\-/).size > 0 value.split(/\_|\-/).map(&:capitalize).join else value.slice(0,1).capitalize + value.slice(1..-1) end end
Converts a string to a Rubified name.
@deprecated Use {PadUtils.camel_case PadUtils.camel_case
} instead as it will
properly sanitize the string as well.
@param value [String] the string to rubify @return [String] the rubified string @example
s = "hello_you" PadUtils.convert_to_ruby_name(s) # => 'HelloYou'
# File lib/pad_utils/pad_text.rb, line 13 def self.convert_to_ruby_name(value) if value.scan(/\_|\-/).size > 0 value.split(/\_|\-/).map(&:capitalize).join else value.slice(0,1).capitalize + value.slice(1..-1) end end
Copies all files from a directory.
@note Will create the destination if it doesn't exist.
Files existing on destination but not on source won't be overwritten.
@param orig_dir [String] the path to source directory @return [Void] nothing @example
PadUtils.copy_all_files("path/to/source", "path/to/destination")
# File lib/pad_utils/pad_files.rb, line 86 def self.copy_all_files(orig_dir, dest_dir) FileUtils.copy_entry(orig_dir, dest_dir) end
Copies a file.
@param file_path [String] the source file name and path @param dest_dir [String] the destination directory @return [Void] nothing @example
PadUtils.copy_file("test.txt", "path/to/destination/directory")
# File lib/pad_utils/pad_files.rb, line 47 def self.copy_file(file_path, dest_dir) FileUtils.cp(file_path, dest_dir) end
Copies an array of files.
@param files [Array<String>] the array of files paths and names to copy @param dest_dir [String] the destination path @return [Void] nothing @example
files = ["file1.txt", "path/to/file2.txt", "path/to/files/file3.txt"] PadUtils.copy_files(files, "path/to/destination")
# File lib/pad_utils/pad_files.rb, line 71 def self.copy_files(files, dest_dir) files.each do |f| copy_file(f, dest_dir) end end
Creates a directory.
@note Won't override directory content if it already exists.
@param dir_name [String] the directory path and name (add `/.`) @return [Void] nothing @example
PadUtils.create_directory("path/to/dir/.")
# File lib/pad_utils/pad_files.rb, line 98 def self.create_directory(dir_name) dirname = File.dirname(dir_name) unless File.directory?(dirname) FileUtils.mkdir_p(dirname) end end
Decrypts a string.
@param content [String] the encrypted string @param key [String] the encryption key @return [String] the decrypted string @example
PadUtils.decrypt("DKBJVYG69YsAWT%0A__1f346a8eeedc7", "s3cr3t") # => 'Hello'
# File lib/pad_utils/pad_security.rb, line 44 def self.decrypt(content: "", key: "") cipher = OpenSSL::Cipher::Cipher.new("aes-256-cbc") cipher.decrypt key = Digest::SHA1.hexdigest(key) iv = content.split("__")[1] content = content.split("*+*")[0] cipher.key = key cipher.iv = iv content = URI.unescape(content) content = Base64.decode64(content) decrypted = '' << cipher.update(content) << cipher.final decrypted rescue decrypted = "invalid" end
Converts keys and sub-keys to symbols in a hash.
Emulates Rails {apidock.com/rails/Hash/deep_symbolize_keys deep_symbolize_keys} method.
@param hash [Hash] the hash to symbolize @return [Hash] the symbolized hash @example
h = {"name": "Nico", "age": 37, "computers": [{"model": "Mac Pro"}, {"model": "MacBook"}]} PadUtils.deep_symbolize_hash_keys(h) # => {:name => "Nico", :age => 37, :computers => [{:model => "Mac Pro"}, {:model => "MacBook"}]}
# File lib/pad_utils/pad_json.rb, line 15 def self.deep_symbolize_hash_keys(hash) return hash.collect { |e| deep_symbolize_hash_keys(e) } if hash.is_a?(Array) return hash.inject({}) { |sh,(k,v)| sh[k.to_sym] = deep_symbolize_hash_keys(v); sh } if hash.is_a?(Hash) hash end
Deletes a directory and its content
@param dir_name [String] the directory path and name @return [Void] nothing @example
PadUtils.delete_directory("path/to/dir")
# File lib/pad_utils/pad_files.rb, line 111 def self.delete_directory(dir_name) FileUtils.rm_r(dir_name) end
Deletes a file.
@param file_path [String] the file path and name @return [Void] nothing @example
PadUtils.delete("path/to/file.txt")
# File lib/pad_utils/pad_files.rb, line 15 def self.delete_file(file_path) FileUtils.rm(file_path, force: true) end
Deletes a file recursively.
@param path [String] the path to search recurively @param filename [String] the filename to search and delete. `*` wildcard accepted @return [Void] nothing @example
PadUtils.delete_recursive("images/photos", ".DS_Store")
# File lib/pad_utils/pad_files.rb, line 26 def self.delete_recursive(path, filename) Dir.glob("#{path}/**/#{filename}").each { |f| File.delete(f) } end
Encrypts a string.
@param content [String] the content to encrypt @param key [String] the encryption key @return [String] the encrypted string @example
PadUtils.encrypt("Hello", "s3cr3t") # => 'DKBJVYG69YsAWT%0A__1f346a8eeedc7'
# File lib/pad_utils/pad_security.rb, line 15 def self.encrypt(content: "", key: "") cipher = OpenSSL::Cipher::Cipher.new("aes-256-cbc") cipher.encrypt iv = PadUtils.uuid.gsub("-", "") key = Digest::SHA1.hexdigest(key) cipher.key = key cipher.iv = iv encrypted = '' << cipher.update(content) << cipher.final encrypted = Base64.encode64(encrypted) encrypted = URI.escape(encrypted, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")) encrypted = "#{encrypted}__#{iv}" rescue encrypted = "invalid" end
Extracts a zip file.
@note If the target path doesn't exist, it will be created. Existing files
will **not** be overwritten.
@param filename [String] the path and name of the zip file @param target_path [String] the target directory where to extract the file
# File lib/pad_utils/pad_compression.rb, line 13 def self.extract_zip(filename, target_path) # Unzip the content Zip::File.open(filename) do |zip_file| zip_file.each do |f| f_path=File.join(target_path, f.name) FileUtils.mkdir_p(File.dirname(f_path)) zip_file.extract(f, f_path) unless File.exist?(f_path) end end # Get rid of these filthy OS X files PadUtils.delete_directory "#{target_path}/__MACOSX" if PadUtils.file_exist?("#{target_path}/__MACOSX") PadUtils.delete_recursive("#{target_path}", ".DS_Store") end
Checks if a file exists.
@param file_path [String] the file path and name @return [Boolean] @example
PadUtils.file_exist?("path/to/file.txt")
# File lib/pad_utils/pad_files.rb, line 36 def self.file_exist?(file_path) File.exist?(file_path) end
Create a class from a filename.
**Don't forget to `require_relative` the file**
@param file [String] the file path and name. Must be a Ruby (`.rb`) file. @return [Object] the class generated from the file @example
require_relative 'somepath/foo_bar' foobar = PadUtils.filename_to_class("somepath/foo_bar.rb") f = foobar.new
# File lib/pad_utils/pad_code.rb, line 27 def self.filename_to_class(file) class_name = PadUtils.filename_to_classname(file) Object.const_get(class_name) end
Converts a Ruby filename to a class name
@param file [String] the file path and name. Must be a Ruby (`.rb`) file. @return [String] the class name @example
PadUtils.filename_to_class("foo_bar.rb") # => FooBar
# File lib/pad_utils/pad_code.rb, line 10 def self.filename_to_classname(file) filename = File.basename file filename_no_ext = filename.gsub(".rb", "") class_name = PadUtils.camel_case(filename_no_ext) class_name end
# File lib/pad_utils.rb, line 51 def self.generate_rsa(type, path) if type == "private" PadUtils.generate_rsa_private_key path: path end if type == "public" PadUtils.generate_rsa_public_key private_key: path, path: "public.pem" end end
Generates a RSA private key.
@param key_size [Integer] key size (*defaults to 2048*) @param path [String] optional path to save the private key @return [RSA] the RSA private key @example
PadUtils.generate_rsa_private_key 3096 # => <RSA key...>
# File lib/pad_utils/pad_security.rb, line 74 def self.generate_rsa_private_key(key_size: 2048, path: nil) key = OpenSSL::PKey::RSA.generate key_size if !path.nil? File.open(path, 'w') { |file| file.write(key.to_pem) } end key end
Generates a RSA public key.
@param private_key [RSA, String] the private key as an RSA key or a pem file path @param path [String] optional path to save the public key @return [RSA] the RSA public key @example
PadUtils.generate_rsa_public_key "private.pem" # => <RSA key...>
# File lib/pad_utils/pad_security.rb, line 89 def self.generate_rsa_public_key(private_key: nil, path: nil) key = nil if private_key.class == OpenSSL::PKey::RSA key = private_key.public_key elsif private_key.class == String private_key = OpenSSL::PKey::RSA.new(File.read(private_key)) key = PadUtils.generate_rsa_public_key private_key: private_key end if !path.nil? && !key.nil? File.open(path, 'w') { |file| file.write(key.to_pem) } end key end
Gets a value from a Ruby config file.
*This method is some kind of UFO but it is heavily used in Padstone.
It is made to retrieve the value inside a Rails config file or initializer such as getting the value of `config.eager_load` in `production.rb`. Everything gets returned as a string or as nil if not found.*
Will log errors using {PadUtils.log PadUtils.log
}.
@param key [String] the config key to look for @param file [String] the file path and name containing the key @return [String, nil] the value returned as a string or nil @example
PadUtils.get_config_value("config.eager_load", "production.rb") # => 'true'
# File lib/pad_utils/pad_text.rb, line 128 def self.get_config_value(key, file) content = PadUtils.get_file_content(file) content.each_line do |line| if line.strip.start_with? key return line.gsub(key, "").gsub("=","").strip end end nil rescue Exception => e PadUtils.log("Error in get_config_value", e) end
Reads the whole content of a file into a string.
Will log errors using {PadUtils.log PadUtils.log
}.
@param filepath [String] the file path and name @return [String] the content of the file @example
PadUtils.get_file_content("path/to/file.txt")
# File lib/pad_utils/pad_files.rb, line 123 def self.get_file_content(filepath) File.read(filepath) rescue Exception => e PadUtils.log("Error in get_file_content", e) end
Convert a hash to a JSON string.
@param hash [Hash] the hash to convert @return [String] the JSON string @example
h = {name: "Nico", age: 37} PadUtils.hash_to_json(h) # => '{"name": "Nico", "age": 37}'
# File lib/pad_utils/pad_json.rb, line 55 def self.hash_to_json(hash) hash.to_json end
Writes a hash to a JSON file.
@note Will overwrite the file if it already exists.
@param filename [String] the file path and name to write to @param hash [Hash] the hash to convert to JSON and write @return [String] the JSON string @example
h = {name: "Nico", age: 37} PadUtils.hash_to_json_file("path/to/json_file.txt", h) # => '{"name": "Nico", "age": 37}'
# File lib/pad_utils/pad_json.rb, line 69 def self.hash_to_json_file(filename, hash) json = hash.to_json PadUtils.write_to_file(filename, json) json end
Display version of PadUtils
if no switches are passed.
# File lib/pad_utils.rb, line 62 def self.help puts PadUtils.puts_c "PadUtils v.#{PadUtils::VERSION}", :green puts puts "Part of the Padstone app builder (http://padstone.io)" puts puts "Copyright 2016 - Nico Schuele" puts "Licensed under the Apache License, Version 2.0" puts end
Sends a HTTP GET request and receives a hash.
@note Although it can parse any JSON responses, this method is made to work
in conjunction with PadUtils on the server side code.
If the server can't be reached, `{error: “Server unreachable”}` is returned.
If the JSON in the response can't be parsed (or if it's not JSON),
`{error: "Response is not JSON"}` is returned.
@param url [String] the url to call @param headers [Hash] the hash containing the header key/value pairs @return [Hash] the response as a hash @example
url = "http://example.com/api/weather" PadUtils.http_get(url) # => {Geneva: "Sunny", Lausanne: "Cloudy"}
# File lib/pad_utils/pad_http.rb, line 72 def self.http_get(url, headers: {'User-Agent' => 'Padstone'}) reply_hash = {} reply = HTTParty.get(url, headers: headers).to_s reply_hash = PadUtils.json_to_hash reply reply_hash rescue JSON::ParserError => e reply_hash = {error: "Response is not JSON"} rescue Errno::ECONNREFUSED => e reply_hash = {error: "Server unreachable"} rescue Exception => e reply_hash = {error: e.message} end
Downloads a file API-frienldy.
@note Warning: If the server answers with an error message, no error will
be raised and the `target` file be created with the content of the error message.
@param url [String] @param target [String] the local target file path and name @param headers [Hash] the hash containing the header key/value pair @return [String] the target path and name or the error message @example
PadUtils.http_get_file("http:/example.com/v1/get_file", "image.jpg") # => "image.jpg"
# File lib/pad_utils/pad_http.rb, line 96 def self.http_get_file(url, target, headers: {'User-Agent' => 'Padstone'}) File.open(target, "wb") do |f| f.binmode f.write HTTParty.get(url).parsed_response end if File.size(target) < 1 PadUtils.delete_file(target) "File not found" else target end rescue Errno::ECONNREFUSED => e PadUtils.delete_file(target) "Server unreachable" rescue Exception => e PadUtils.delete_file(target) e.message end
Sends a HTTP GET request and receives plain text.
If the server can't be reached, `“Server unreachable”` is returned.
@param url [String] the url to call @param headers [Hash] the hash containing the header key/value pairs @return [String] the response @example
url = "http://example.com/api/joke" PadUtils.http_get_plain(url) # => "There are 10 kinds of programmers."
# File lib/pad_utils/pad_http.rb, line 48 def self.http_get_plain(url, headers: {'User-Agent' => 'Padstone'}) reply = HTTParty.get(url, headers: headers).to_s rescue Errno::ECONNREFUSED => e reply = "Server unreachable" rescue Exception => e reply = e.message end
Sends a HTTP POST request.
@note Although it can parse any JSON responses, this method is made to work
in conjunction with PadUtils on the server side code.
If the server can't be reached, `{error: “Server unreachable”}` is returned.
If the JSON in the response can't be parsed (or if it's not JSON),
`{error: "Response is not JSON"}` is returned.
@param url [String] the url to call @param body [Hash] the hash containing the key/value pairs to send @param headers [Hash] the hash containing the header key/value pairs @return [Hash] the response as a hash @example
url = "http://example.com/api/movies" body = {year: 2008, director: "Nolan"} PadUtils.http_post(url: url, body: body) # => {movie: "The Dark Knight"}
# File lib/pad_utils/pad_http.rb, line 23 def self.http_post(url: "", body: {}, headers: {'User-Agent' => 'Padstone'}) reply_hash = {} body = PadUtils.hash_to_json(body) reply = HTTParty.post(url, {headers: headers, body: body}).to_s reply_hash = PadUtils.json_to_hash reply reply_hash rescue JSON::ParserError => e reply_hash = {error: "Response is not JSON"} rescue Errno::ECONNREFUSED => e reply_hash = {error: "Server unreachable"} rescue Exception => e reply_hash = {error: e.message} end
Inserts text after the first occurence of a string.
Can be used on a string or on a file.
Will log errors using {PadUtils.log PadUtils.log
}.
@param original [String] the original file path and name or the original string @param tag [String] the string to find @param text [String] the string to insert @param is_file [Boolean] `true` if `original` is a file, `false` if it is a string @return [String] the new content @example
PadUtils.insert_after_first(original: "file.txt", tag: "end", text: "# hello!")
# File lib/pad_utils/pad_text.rb, line 327 def self.insert_after_first(original: nil, tag: nil, text: nil, is_file: true) # The new text will be consolidated in content content = "" # If coming from a file, read original into content if is_file content = PadUtils.get_file_content(original) else content = original end # Iterate line by line. If a position is found, insert the text # and set found to true to prevent further insertions found = false new_content = "" content.each_line do |line| position = line.index(/#{tag}/) if position && !found new_content += "#{line}#{text}" found = true else new_content += line end end # If coming from a file, write result in same file. If not, # simply return content if is_file PadUtils.write_to_file(original, new_content) return new_content else return new_content end rescue Exception => e PadUtils.log("Error in insert_after_first", e) end
Inserts text after the last occurence of a string.
Can be used on a string or on a file.
Will log errors using {PadUtils.log PadUtils.log
}.
@param original [String] the original file path and name or the original string @param tag [String] the string to find @param text [String] the string to insert @param is_file [Boolean] `true` if `original` is a file, `false` if it is a string @return [String] the new content @example
PadUtils.insert_after_last(original: "file.txt", tag: "end", text: "# hello!")
# File lib/pad_utils/pad_text.rb, line 378 def self.insert_after_last(original: nil, tag: nil, text: nil, is_file: true) # The new text will be consolidated in content content = "" # If coming from a file, read original into content if is_file content = PadUtils.get_file_content(original) else content = original end # Find the position of tag in the string array and insert the text positions = content.enum_for(:scan, /#{tag}/).map { Regexp.last_match.begin(0) } content[positions.last + tag.length] = "#{text}" # If coming from a file, write result in same file. If not, # simply return content if is_file PadUtils.write_to_file(original, content) return content else return content end rescue Exception => e PadUtils.log("Error in insert_after_last", e) end
Inserts text before the first occurence of a string.
Can be used on a string or on a file.
Will log errors using {PadUtils.log PadUtils.log
}.
@param original [String] the original file path and name or the original string @param tag [String] the string to find @param text [String] the string to insert @param is_file [Boolean] `true` if `original` is a file, `false` if it is a string @return [String] the new content @example
PadUtils.insert_before_first(original: "file.txt", tag: "end", text: "# hello!")
# File lib/pad_utils/pad_text.rb, line 235 def self.insert_before_first(original: nil, tag: nil, text: nil, is_file: true) # The new text will be consolidated in content content = "" # If coming from a file, read original into content if is_file content = PadUtils.get_file_content(original) else content = original end # Iterate line by line. If a position is found, insert the text # and set found to true to prevent further insertions found = false new_content = "" content.each_line do |line| position = line.index(/#{tag}/) if position && !found new_content += "#{text}#{line}" found = true else new_content += line end end # If coming from a file, write result in same file. If not, # simply return content if is_file PadUtils.write_to_file(original, new_content) return new_content else return new_content end rescue Exception => e PadUtils.log("Error in insert_before_first", e) end
Inserts text before the last occurence of a string.
Can be used on a string or on a file.
Will log errors using {PadUtils.log PadUtils.log
}.
@param original [String] the original file path and name or the original string @param tag [String] the string to find @param text [String] the string to insert @param is_file [Boolean] `true` if `original` is a file, `false` if it is a string @return [String] the new content @example
PadUtils.insert_before_last(original: "file.txt", tag: "end", text: "# hello!")
# File lib/pad_utils/pad_text.rb, line 286 def self.insert_before_last(original: nil, tag: nil, text: nil, is_file: true) # The new text will be consolidated in content content = "" # If coming from a file, read original into content if is_file content = PadUtils.get_file_content(original) else content = original end # Find the position of tag in the string array and insert the text positions = content.enum_for(:scan, /#{tag}/).map { Regexp.last_match.begin(0) } content[positions.last - 1] = "#{text}" # If coming from a file, write result in same file. If not, # simply return content if is_file PadUtils.write_to_file(original, content) return content else return content end rescue Exception => e PadUtils.log("Error in insert_before_last", e) end
Returns the interval of time between two Time objects.
@param start_time [Time] the starting time @param end_time [Time] the ending time @param unit [Symbol] the unit to use from `:seconds`, `:minutes`, `:hours`, `:days` @return [Float] the interval, rounded at 3 digits @example
start = Time.now - 30 finish = Time.now PadUtils.interval(start, finish, :minutes) # => 0.5
# File lib/pad_utils/pad_time.rb, line 63 def self.interval(start_time, end_time, unit = :seconds) result = -1 inter = (end_time - start_time) if unit == :minutes result = inter / 60.0 elsif unit == :hours result = (inter / 60) / 60 elsif unit == :days result = ((inter / 60) / 60) / 24 else result = inter end result.round(3) end
Converts a JSON file to a symbolized hash.
Reads a JSON file and calls {PadUtils.deep_symbolize_hash_keys} on its content.
@param json_file [String] the json file path and name @return [Hash] the symbolized hash @example
PadUtils.json_file_to_hash("path/to/file")
# File lib/pad_utils/pad_json.rb, line 42 def self.json_file_to_hash(json_file) jfile = PadUtils.get_file_content(json_file) h = JSON.parse(jfile) self.deep_symbolize_hash_keys(h) end
Converts a JSON string to a symbolized hash.
Calls {PadUtils.deep_symbolize_hash_keys} on a JSON formatted string.
@param json [String] the JSON string to convert @return [Hash] the symbolized hash @example
PadUtils.json_to_hash(a_json_string)
# File lib/pad_utils/pad_json.rb, line 29 def self.json_to_hash(json) h = JSON.parse(json) self.deep_symbolize_hash_keys(h) end
Logs a message.
@note If using the method within a rescue block, pass the exception from
`rescue Exception => e`
@param message [String] the message to log @param e [Exception] the raised exception @return [Void] nothing @example
def faulty_method a = 0 b = 3 c = b / a rescue Exception => e PadUtils.log("Something bad happened!", e) end
# File lib/pad_utils/pad_logger.rb, line 47 def self.log(message, e = nil) # Create the log directory if it doesn't exist PadUtils.create_directory(@@log_path) # Add a timestamp to the message message = "#{PadUtils.time_to_stamp(Time.now)}: #{message}" # If an error is added, add its inner message to the message # as well as the whole stack if e != nil message = "#{message}\n\tError: #{e.message} (#{e.class.name})" stack = e.backtrace.inspect.split(",") stack.each do |s| message = "#{message}\n\t\t#{s}" end message = "#{message}\n" end # Adds the message to the log file PadUtils.append_to_file("#{@@log_path}/#{@@log_file}", message) end
Entry point for the executable.
# File lib/pad_utils.rb, line 22 def self.main(arg) if arg[0] == '-u' PadUtils.puts_c PadUtils.uuid, :blue elsif arg[0] == '-e' if arg[1].nil? || arg[2].nil? puts PadUtils.puts_c "padutils -e <word to encrypt> <encryption key>" else PadUtils.puts_c PadUtils.encrypt content: arg[1], key: arg[2] end elsif arg[0] == '-d' if arg[1].nil? || arg[2].nil? puts PadUtils.puts_c "padutils -d <string to decrypt> <encryption key>" else PadUtils.puts_c PadUtils.decrypt content: arg[1], key: arg[2] end elsif arg[0] == '--rsa' if arg[1].nil? || arg[2].nil? puts PadUtils.puts_c "padutils --rsa <private | public> <path/to/key.pem>", :blue else generate_rsa arg[1], arg[2] end else help end end
Moves a file.
@param file_path [String] the source file path and name @param dest_file [String] the destination path and name @return [Void] nothing @example
PadUtils.move_file("source.txt", "path/to/destination/renamed.txt")
# File lib/pad_utils/pad_files.rb, line 59 def self.move_file(file_path, dest_file) FileUtils.mv(file_path, dest_file, force: true) end
Colorizes the cli output.
Colors have aliases:
-
`:blue` => `:note`, `:emphasis`
-
`:red` => `:error`, `:danger`, `:alert`, `:failure`
-
`:green` => `:correct`, `:success`, `:info`
@param text [String] the string to output @param highlight [Symbol, nil] the color to be used (`:red`, `:green`, `:blue`, `nil`) @param wrap [Boolean] if `true`, will wrap the text at 80 characters @return [Void] nothing @example
PadUtils.puts_c "Hello World", :green
# File lib/pad_utils/pad_color.rb, line 17 def self.puts_c(text, highlight = nil, wrap = true) # Set color codes red = 31 green = 32 blue = 36 # Set color to use current_color = nil case highlight when :red, :error, :danger, :alert, :failure current_color = red when :green, :correct, :success, :info current_color = green when :blue, :note, :emphasis current_color = blue else current_color = nil end # Wrap the text if wrap text = text.gsub(/\n/, ' ').gsub(/(.{1,#{79}})(\s+|$)/, "\\1\n").strip end # Just display text if no color chosen. Else, colorize it. if current_color == nil STDOUT.puts text else STDOUT.puts "\e[#{current_color}m#{text}\e[0m" end end
Returns a Time object from a readable timestamp.
Will log errors using {PadUtils.log PadUtils.log
}.
@param val [String] the readable timestamp formatted as `YYYY-MM-DD HH:mm:ss` @return [Time] the Time object
# File lib/pad_utils/pad_time.rb, line 47 def self.readable_stamp_to_time(val) Time.parse val rescue Exception => e PadUtils.log("Error in readable_stamp_to_time", e) end
Replaces text in a file.
Will log errors using {PadUtils.log PadUtils.log
}.
@param file [String] the file path and name @param old_text [String, Regexp] the text to find as a string or regex @param new_text [String] the new text @return [Void] nothing @example
PadUtils.replace_in_file("example.txt", /some_text/, "new text")
# File lib/pad_utils/pad_text.rb, line 84 def self.replace_in_file(file, old_text, new_text) text_update = PadUtils.get_file_content(file) text_update = text_update.gsub(old_text, new_text) PadUtils.write_to_file(file, text_update) rescue Exception => e PadUtils.log("Error replacing #{old_text} in #{file} with #{new_text}", e) end
Replaces multiple strings in a file.
Will log errors using {PadUtils.log PadUtils.log
}.
@param file [String] the file path and name @param values [Array] the array containing hashes of `key`, `value` @return [Void] nothing @example
values = [ {key: /REPLACE_ME/, value: "REPLACED"}, {key: /REPLACE_ALSO/, value: "MODIFIED AS WELL"} ] PadUtils.replace_keys_in_file("example.txt", values)
# File lib/pad_utils/pad_text.rb, line 106 def self.replace_keys_in_file(file, values) values.each do |value| PadUtils.replace_in_file(file, value[:key], value[:value]) end rescue Exception => e PadUtils.log("Error replacing multiple keys in #{file}", e) end
Replaces a line in a file containing a specific value.
Will log errors using {PadUtils.log PadUtils.log
}.
@param value [String] the value to search for in a line @param in_file [String] the file path and name where to search @param new_value [String] the value replacing the line @return [Void] nothing @example
PadUtils.replace_line_containing("Config.port", in_file: "config.rb", new_value: "Config.port = 232")
# File lib/pad_utils/pad_text.rb, line 207 def self.replace_line_containing(value, in_file: nil, new_value: nil) content = PadUtils.get_file_content(in_file) new_content = "" content.each_line do |line| if line.include? value new_content << "#{new_value}\n" else new_content << line end end PadUtils.write_to_file(in_file, new_content) rescue Exception => e PadUtils.log("Error in replace_line_containing", e) end
Decrypts a string with a RSA private key.
@param content [String] the string to decrypt @param public_key [RSA, String] the private key as an RSA key or a pem file path @return [String] the decrypted string @example
PadUtils.rsa_private_decrypt "mwRAHtpE9...", "private.pem" # => 'Hello!'
# File lib/pad_utils/pad_security.rb, line 126 def self.rsa_private_decrypt(content: nil, private_key: nil) if private_key.class == String private_key = OpenSSL::PKey::RSA.new(File.read(private_key)) end private_key.private_decrypt(Base64.decode64(content)) end
Encrypts a string with a RSA private key.
@param content [String] the string to encrypt @param public_key [RSA, String] the private key as an RSA key or a pem file path @return [String] the encrypted string @example
PadUtils.rsa_private_encrypt "Hello!", "private.pem" # => 'mwRAHtpE9...'
# File lib/pad_utils/pad_security.rb, line 141 def self.rsa_private_encrypt(content: nil, private_key: nil) if private_key.class == String private_key = OpenSSL::PKey::RSA.new(File.read(private_key)) end Base64.encode64(private_key.private_encrypt(content)) end
Decrypts a string with a RSA public key.
@param content [String] the string to decrypt @param public_key [RSA, String] the public key as an RSA key or a pem file path @return [String] the decrypted string @example
PadUtils.rsa_public_decrypt "mwRAHtpE9...", "public.pem" # => 'Hello!'
# File lib/pad_utils/pad_security.rb, line 156 def self.rsa_public_decrypt(content: nil, public_key: nil) if public_key.class == String public_key = OpenSSL::PKey::RSA.new(File.read(public_key)) end public_key.public_decrypt(Base64.decode64(content)) end
Encrypts a string with a RSA public key.
@param content [String] the string to encrypt @param public_key [RSA, String] the public key as an RSA key or a pem file path @return [String] the encrypted string @example
PadUtils.rsa_public_encrypt "Hello!", "public.pem" # => 'mwRAHtpE9...'
# File lib/pad_utils/pad_security.rb, line 111 def self.rsa_public_encrypt(content: nil, public_key: nil) if public_key.class == String public_key = OpenSSL::PKey::RSA.new(File.read(public_key)) end Base64.encode64(public_key.public_encrypt(content)) end
Sanitizes a string.
Will only allow alphanumeric characters and underscores.
@param value [String] the string to sanitize @return [String] the sanitized string @example
PadUtils.sanitize("Abc Def *34*#yXz") # => 'Abc_Def__34__yXz'
# File lib/pad_utils/pad_text.rb, line 70 def self.sanitize(value) value.tr('^A-Za-z0-9', '_') end
Sets a value in a Ruby config file.
*This is another method typically used by Padstone to write
new config values in Rails config files such as `production.rb` or overwrite existing ones.*
Will log errors using {PadUtils.log PadUtils.log
}.
@param key [String] the config key to find (or create) @param value [String] the value to set @param file [String] the file path and name of the file to overwrite @param comment [String] the optional comment to add before the key @return [Void] nothing @example
key = "config.assets.digest" value = "false" file = "production.rb" PadUtils.set_config_value(key, value, file, "Overwritten with PadUtils")
# File lib/pad_utils/pad_text.rb, line 158 def self.set_config_value(key, value, file, comment = nil) # read the config file content = PadUtils.get_file_content(file) # set some vars found = false new_content = "" # for each line in the file, check if one contains the key. # If the key is found, get its position so we can indent the # config line properly. content.each_line do |line| position = line.index(key) if position != nil new_line = "" (0..position - 1).each do |p| new_line << " " end if comment != nil new_content << "#{new_line}# #{comment}\n" end new_content << "#{new_line}#{key} = #{value}\n" found = true else new_content << line end end # If the config key was not found, we'll insert it before the last end, # indented with two spaces if !found PadUtils.insert_before_last(original: file, tag: 'end', text: "\n\n # #{comment == nil ? key : comment}\n #{key} = #{value}\n") else PadUtils.write_to_file(file, new_content) end rescue Exception => e PadUtils.log("Error in set_config_value", e) end
Sets a different log file.
@param val [String] the log file name @return [String] the log file name @example
PadUtils.set_log_file("my_logs.txt") # => 'my_logs.txt'
# File lib/pad_utils/pad_logger.rb, line 27 def self.set_log_file(val) @@log_file = val end
Sets a different log path.
@param val [String] the path to the directory @return [String] the log directory path @example
PadUtils.set_log_path("path/directory") # => 'path/directory'
# File lib/pad_utils/pad_logger.rb, line 17 def self.set_log_path(val) @@log_path = val end
Returns a Time object from a string timestamp.
Will log errors using {PadUtils.log PadUtils.log
}.
@param val [String] a string formatted as `YYYYMMDDHHmmss` @return [Time] the Time object @example
PadUtils.stamp_to_time("20160227160122")
# File lib/pad_utils/pad_time.rb, line 25 def self.stamp_to_time(val) Time.parse "#{val[0..3]}-#{val[4..5]}-#{val[6..7]} #{val[8..9]}:#{val[10..11]}:#{val[12..13]}" rescue Exception => e PadUtils.log("Error in stamp_to_time", e) end
Returns a readable string timestamp.
Format `YYYY-MM-DD HH:mm:ss` will be used.
@param val [Time] the Time object to convert @return [String] the readable timestamp
# File lib/pad_utils/pad_time.rb, line 37 def self.time_to_readable_stamp(val) val.strftime("%Y-%m-%d %H:%M:%S") end
Returns a string timestamp.
Format `YYYYMMDDHHmmss` will be used.
@param val [Time] the Time object to convert @return [String] the timestamp @example
PadUtils.time_to_stamp(Time.now) # => 20160227160122
# File lib/pad_utils/pad_time.rb, line 13 def self.time_to_stamp(val) val.strftime("%Y%m%d%H%M%S") end
Converts a CamelCase string to an underscore string.
Taken from the Rails {api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-underscore Inflector} class.
@param val [String] the CamelCase string to underscore @return [String] the under_score string @example
PadUtils.underscore("CamelCase") # => camel_case
# File lib/pad_utils/pad_text.rb, line 52 def self.underscore(val) word = val.dup word.gsub!(/::/, '/') word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2') word.gsub!(/([a-z\d])([A-Z])/,'\1_\2') word.tr!("-", "_") word.downcase! word end
Generate UUID's.
@param count [Int] how many uuid's to generate @return [String, Array<String>] if only one uuid generated, returns a `String`. If not, an `Array`. @example
PadUtils.uuid(2) # => ["96b0a57c-d9ae-453f-b56f-3b154eb10cda", "332a0fa3-7b07-41e1-9fc8-ef804a377e4e"]
# File lib/pad_utils/pad_code.rb, line 38 def self.uuid(count = 1) if count == 1 SecureRandom.uuid else result = [] (1..count).each do result << SecureRandom.uuid end result end end
Writes content to a file.
@note Will create destination file if it doesn't exist.
Will also overwrite the file if it already exists.
Will log errors using {PadUtils.log PadUtils.log
}.
@param filepath [String] the file path and name @param content [String] the content to be written @return [Void] nothing @example
PadUtils.write_to_file("path/to/file", "Hello\nThis is a test")
# File lib/pad_utils/pad_files.rb, line 141 def self.write_to_file(filepath, content) self.create_directory(filepath) File.open(filepath, 'w') { |f| f.write(content)} rescue Exception => e PadUtils.log("Error in write_to_file", e) end