blufin-lib 1.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 28d9f465ff5230d850d2c1d876a4e105bf077559
+  data.tar.gz: ff911b1d347254a0054140b7fcd148a5641cfaa3
+SHA512:
+  metadata.gz: 34aa1c67ceae7a75988e3169616ede84b5a21b91d46f09266e47fb35a8bb85e3adfe51860d7a62ffea085fe9df7cce11467af4ee27f33a4bea4380bc5e7001bd
+  data.tar.gz: 5745185edb426f42e9d7eb6c62b3b7c26507cff9de7ea4b4e14633206d00e79b8aaf1e78ba27d2c9ef4fefe4b6543ce051e11c6fde6549e222848615a1ad62c0

data/lib/blufin-lib.rb

@@ -0,0 +1,22 @@
+module Blufin
+
+    autoload :Arrays, 'blufin-lib/core/arrays'
+    autoload :Browser, 'blufin-lib/core/browser'
+    autoload :DateTimeUtils, 'blufin-lib/core/datetime_utils'
+    autoload :Encryptor, 'blufin-lib/core/encryptor'
+    autoload :Files, 'blufin-lib/core/files'
+    autoload :Network, 'blufin-lib/core/network'
+    autoload :Numbers, 'blufin-lib/core/numbers'
+    autoload :Routes, 'blufin-lib/core/routes'
+    autoload :SSH, 'blufin-lib/core/ssh'
+    autoload :Strings, 'blufin-lib/core/strings'
+    autoload :Terminal, 'blufin-lib/core/terminal'
+    autoload :Tools, 'blufin-lib/core/tools'
+
+    module Test
+
+        autoload :EnvironmentValidator, 'blufin-lib/test/TestEnvironmentValidator'
+
+    end
+
+end

data/lib/blufin-lib/core/arrays.rb

@@ -0,0 +1,18 @@
+module Blufin
+
+    class Arrays
+
+        # Checks if an array has duplicates.
+        # @return boolean
+        def self.array_has_duplicate(array, ignore_case = false)
+            raise RuntimeError, "Expected Array, but got #{array.class}" unless array.is_a?(Array)
+            array = array.dup
+            if ignore_case
+                array.map! { |name| name.downcase }
+            end
+            !(array.uniq.length == array.length)
+        end
+
+    end
+
+end

data/lib/blufin-lib/core/browser.rb

@@ -0,0 +1,30 @@
+require 'watir-webdriver'
+
+module Blufin
+
+    class Browser
+
+        # Get a Watir Browser object.
+        # @return [Watir::Browser]
+        def self.get(headless = false)
+
+            # Set the path to phantomjs executable
+            Selenium::WebDriver::PhantomJS.path = '/usr/local/bin/phantomjs'
+
+            browser = Watir::Browser.new (headless ? :phantomjs : :chrome), :switches => %w(--ignore-certificate-errors --test-type)
+
+            width  = 1440
+            height = 2000
+            x      = 0
+            y      = -0
+
+            browser.window.move_to(x, y)
+            browser.window.resize_to(width, height)
+            browser.window.use
+            browser
+
+        end
+
+    end
+
+end

data/lib/blufin-lib/core/datetime_utils.rb

@@ -0,0 +1,14 @@
+module Blufin
+
+    class DateTimeUtils
+
+        # Returns the current DateTime as string. Default format is: %d/%m/%Y %H:%M:%S
+        # @return String
+        def self.now(format = nil)
+            format = '%Y/%m/%d %H:%M:%S' if format.nil?
+            Time.now.strftime(format)
+        end
+
+    end
+
+end

data/lib/blufin-lib/core/encryptor.rb

@@ -0,0 +1,53 @@
+require 'openssl'
+require 'base64'
+
+module Blufin
+
+    class Encryptor
+
+        def initialize(key = nil, hex = nil)
+
+            @key = key
+            @hex = hex
+
+            raise RuntimeError, "Encryptor hasn't been properly initialized. You forgot to pass the CRYPT_KEY + CRYPT_HEX to the constructor when instantiating the class." if @key.nil? || @hex.nil?
+
+        end
+
+        def encrypt(string)
+
+            c = OpenSSL::Cipher.new('aes-256-cbc')
+            c.encrypt
+            c.key = Digest::SHA1.hexdigest(@hex)[0..31]
+            begin
+                d = c.update(string)
+                d << c.final
+                return Base64.encode64(d)
+            rescue => e
+                Blufin::Terminal::error('Encryption failed', "Could not encrypt string \xe2\x86\x92 #{string == '' ? '[blank]' : Blufin::Terminal::format_invalid(string)}", false)
+                Blufin::Terminal::print_exception(e)
+            end
+
+        end
+
+        def decrypt(string)
+
+            string_decoded = Base64.decode64(string)
+            c              = OpenSSL::Cipher.new('aes-256-cbc')
+            c.decrypt
+            c.key = Digest::SHA1.hexdigest(@hex)[0..31]
+            begin
+                d = c.update(string_decoded)
+                d << c.final
+                return d
+            rescue => e
+                Blufin::Terminal::error('Decryption failed', "Could not decrypt string \xe2\x86\x92 #{string == '' ? '[blank]' : Blufin::Terminal::format_invalid(string)}", false)
+                Blufin::Terminal::print_exception(e)
+
+            end
+
+        end
+
+    end
+
+end

data/lib/blufin-lib/core/files.rb

@@ -0,0 +1,385 @@
+require 'fileutils'
+require 'parseconfig'
+
+module Blufin
+
+    class Files
+
+        JAVA_AUTO_GENERATED_EVERY_RUN = 'java_auto_generated_every_run'
+        JAVA_AUTO_GENERATED_ONCE      = 'java_auto_generated_once'
+
+        # Same as write_file() but for Java files. If arrange_imports = TRUE (default) it
+        # will sort the import statements in the same order as IntelliJ would.
+        # @return String
+        def self.write_file_java(path_and_file, array_of_lines, auto_generated = JAVA_AUTO_GENERATED_EVERY_RUN)
+            raise RuntimeError, "Expected String, instead got:#{path_and_file.class}" unless path_and_file.is_a?(String)
+            auto_generated_valid = [JAVA_AUTO_GENERATED_EVERY_RUN, JAVA_AUTO_GENERATED_ONCE]
+            raise RuntimeError, "Expected .java file, instead got: #{path_and_file}" unless path_and_file =~ /\.java\z/
+            raise RuntimeError, "auto_generated must be one of the following: #{auto_generated_valid.join(', ')}" unless auto_generated_valid.include?(auto_generated)
+            package               = nil
+            import_statements_one = []
+            import_statements_two = []
+            previous_was_blank    = false
+            annotations_one       = []
+            annotations_two       = []
+            contents              = []
+            array_of_lines.each do |line|
+                if contents.any?
+                    next if line.strip == '' && previous_was_blank
+                    previous_was_blank = false
+                    contents << line
+                    previous_was_blank = true if line.strip == ''
+                    next
+                end
+                if package.nil? && line.strip =~ /^package\s+[A-Za-z0-9\._-]+;$/
+                    # Get package.
+                    raise RuntimeError, "Package has a hyphen in it \xe2\x86\x92 \x1B[38;5;184m#{line.strip}\x1B[0m. When this file's contents were generated you forgot a .gsub() statement to replace it." if line.strip =~ /-/
+                    package = line.strip
+                    next
+                elsif line.strip =~ /^import\s+[A-Za-z0-9\.*_-]+;$/ || line.strip =~ /^import\s+static\s+[A-Za-z0-9\.*_-]+;$/
+                    # Get import statements.
+                    raise RuntimeError, "Import has a hyphen in it \xe2\x86\x92 \x1B[38;5;184m#{line.strip}\x1B[0m. When this file's contents were generated you forgot a .gsub() statement to replace it." if line.strip =~ /-/
+                    import_statements_one << line.strip
+                    next
+                elsif !contents.any? && line.strip =~ /^@(.)+$/
+                    annotations_one << line.strip
+                elsif !contents.any? && line.strip =~ /^(public|private|protected)\s+.*(class|enum)\s+.*\{$/
+                    contents << line.strip
+                    next
+                end
+            end
+            raise RuntimeError, "Couldn't parse content for: #{path_and_file}" unless contents.any?
+            # Add @AutoGenerated + @TestNotRequired stuff.
+            import_statements_one << 'import org.blufin.base.annotations.AutoGenerated;'
+            import_statements_one << 'import org.blufin.base.annotations.TestNotRequired;'
+            import_statements_one << 'import org.blufin.base.annotations.helper.ON;'
+            annotations_one.each do |annotation|
+                next if %w(@TestNotRequired @AutoGenerated @AutoGenerated(ON.EVERY_RUN) @AutoGenerated(ON.CREATION_ONLY)).include?(annotation)
+                annotations_two << annotation
+            end
+            annotations_two << '@TestNotRequired'
+            annotations_two << ((auto_generated == JAVA_AUTO_GENERATED_EVERY_RUN) ? '@AutoGenerated(ON.EVERY_RUN)' : '@AutoGenerated(ON.CREATION_ONLY)')
+            annotations_two.uniq!
+            import_statements_one.uniq!
+            import_statements_one.sort!
+            package_path = package.gsub(/package\s/, '').gsub(/;/, '').strip
+
+            # Figure out which import statements to "keep" -- IE: Are they being used?
+            import_statements_one.each do |import_statement|
+
+                import_statement_path  = []
+                import_statement_split = import_statement.gsub(/import\s/, '').gsub(/;/, '').strip.split('.')
+                import_statement_split.each_with_index { |n, idx| import_statement_path << n unless idx == (import_statement_split.length - 1) }
+
+                # Skip import if we're in the same package.
+                next if import_statement_path.join('.') == package_path
+
+                found = false
+                is    = import_statement.split('.')
+                is    = is[is.length - 1].gsub(';', '').strip
+                if is == '*'
+                    import_statements_two << import_statement
+                    next
+                end
+                annotations_two.each do |annotation|
+                    if annotation =~ /@#{is}/ || annotation =~ /[\(\.]#{is}[\)\.]/
+                        found = true
+                        break
+                    end
+                end
+                unless found
+                    contents.each do |content_line|
+                        if content_line =~ /[<\(\s{]#{is}[\.<>,\s\(\)]/ || content_line =~ /@#{is}[\(]?/
+                            found = true
+                            break
+                        end
+                    end
+                end
+                import_statements_two << import_statement if found
+            end
+            import_statement_counter = {}
+            import_statement_tracker = {}
+            # Convert multiple imports to .*
+            import_statements_two.each do |import_statement|
+                is                           = import_statement.split('.')
+                is                           = is.first(is.length - 1).join('.')
+                import_statement_counter[is] = 0 if import_statement_counter[is].nil?
+                import_statement_counter[is] += 1
+                import_statement_tracker[is] = [] if import_statement_tracker[is].nil?
+                import_statement_tracker[is] << import_statement
+            end
+            import_statements_one = []
+            import_statements_two.each do |import_statement|
+                is = import_statement.split('.')
+                is = is.first(is.length - 1).join('.')
+                if import_statement_counter[is] > 5
+                    import_statements_one << "#{is}.*;"
+                else
+                    import_statements_one << import_statement
+                end
+            end
+            import_statements_one.uniq!
+            import_statements_one.sort!
+            # Re-assemble the file.
+            final_written_java_non = 0
+            final_written_java     = 0
+            final_contents         = [package, '']
+            # Write NON-JAVA statements.
+            import_statements_one.each do |import_statement|
+                unless import_statement =~ /^import\s+java/ || import_statement =~ /^import\s+static/
+                    final_contents << import_statement
+                    final_written_java_non += 1
+                end
+            end
+            static_statement_found = false
+            # Write STATIC statements.
+            import_statements_one.each do |import_statement|
+                if import_statement =~ /^import\s+static/
+                    unless static_statement_found
+                        final_contents << ''
+                        static_statement_found = true
+                    end
+                    final_contents << import_statement
+                    final_written_java += 1
+                end
+            end
+            final_contents << '' if final_written_java_non > 0
+            # Write JAVA statements.
+            import_statements_one.each do |import_statement|
+                if import_statement =~ /^import\s+java/
+                    final_contents << import_statement
+                    final_written_java += 1
+                end
+            end
+            final_contents << '' if final_written_java > 0
+            annotations_two.each { |line| final_contents << line } if annotations_two.any?
+            contents.each { |line| final_contents << line } if contents.any?
+            return self.write_file(path_and_file, final_contents)
+        end
+
+        # Write an "Array of Lines" to a file -- overwrites file if exists!
+        # @return String
+        def self.write_file(path_and_file, array_of_lines)
+            raise RuntimeError, "Expected String, instead got:#{path_and_file.class}" unless path_and_file.is_a?(String)
+            path_and_file = File.expand_path(path_and_file)
+            raise RuntimeError, "Expected an array of lines to write to file, instead got: #{array_of_lines.class}" unless array_of_lines.is_a? Array
+            prepare_for_file_write(path_and_file)
+            begin
+                File.open(path_and_file, 'w') { |file|
+                    array_of_lines.each_with_index do |line, index|
+                        if index == array_of_lines.size - 1
+                            file.write("#{line}") unless line.to_s.strip == ''
+                        else
+                            file.write("#{line}\n")
+                        end
+                    end
+                    file.close
+                }
+            rescue Exception => e
+                Blufin::Terminal::print_exception(e)
+            end
+            path_and_file
+        end
+
+        # Write a "String" to a file -- overwrites file if exists!
+        # @return void
+        def self.write_file_string(path_and_file, content)
+            raise RuntimeError, "Expected String, instead got:#{path_and_file.class}" unless path_and_file.is_a?(String)
+            path_and_file = File.expand_path(path_and_file)
+            raise RuntimeError, "Expected String to write to file, instead got: #{content.class}" unless content.is_a? String
+            prepare_for_file_write(path_and_file)
+            begin
+                File.open(path_and_file, 'w') { |file|
+                    file.write("#{content}")
+                    file.close
+                }
+            rescue Exception => e
+                Blufin::Terminal::print_exception(e)
+            end
+        end
+
+        # Writes a line to a file.
+        # regex -> If a value exists the program checks for this regex and writes on the line AFTER match(es). if nil (or not found), writes at the end of file.
+        # only_if_not_exists -> If TRUE, will add line only if it doesn't already exist.
+        # replace -> If TRUE, will replace file rather than writing on next line after regex.
+        # @return void
+        def self.write_line_to_file(path_and_file, line, regex = nil, only_if_not_exists = true, replace = false)
+            raise RuntimeError, "Expected String, instead got:#{path_and_file.class}" unless path_and_file.is_a?(String)
+            path_and_file = File.expand_path(path_and_file)
+            raise RuntimeError, "File not found: #{path_and_file}" unless file_exists(path_and_file)
+            raise RuntimeError, "Expected String to write to file, instead got: #{line.class}" unless line.is_a? String
+            raise RuntimeError, "Expected Regexp to match to line, instead got: #{regex.class}" unless regex.nil? || regex.is_a?(Regexp)
+            raise RuntimeError, 'Cannot set replace to TRUE when regex is nil.' if regex.nil? && replace
+            raise RuntimeError, 'only_if_not_exists must be set to FALSE when replace is TRUE.' if only_if_not_exists && replace
+            new_lines = []
+            if only_if_not_exists
+                line_found = false
+                read_file(path_and_file).each do |line_content|
+                    line_content.gsub!(/\n\z/, '')
+                    line_found = true if line_content == line
+                end
+                return if line_found
+            end
+            if !regex.nil? && !replace
+                regex_found   = false
+                line_inserted = false
+                read_file(path_and_file).each do |line_content|
+                    line_content.gsub!(/\n\z/, '')
+                    regex_found = true if line_content =~ regex
+                    if regex_found && line_content !~ regex && !line_inserted
+                        new_lines << line
+                        line_inserted = true
+                    end
+                    new_lines << line_content
+                end
+                new_lines << line unless line_inserted
+            elsif !regex.nil? && replace
+                regex_found = false
+                read_file(path_and_file).each do |line_content|
+                    line_content.gsub!(/\n\z/, '')
+                    if !regex_found && line_content =~ regex
+                        regex_found = true
+                        new_lines << line
+                    else
+                        new_lines << line_content
+                    end
+                end
+            end
+            write_file(path_and_file, new_lines)
+        end
+
+        # Removes a line from a file.
+        # multiple_occurrences -> If set to TRUE, will remove ALL occurrences from file.
+        # @return void
+        def self.remove_line_from_file(path_and_file, regex, multiple_occurrences = false)
+            raise RuntimeError, "Expected String, instead got:#{path_and_file.class}" unless path_and_file.is_a?(String)
+            path_and_file = File.expand_path(path_and_file)
+            raise RuntimeError, "Expected Regexp to match to line, instead got: #{regex.class}" unless regex.is_a? Regexp
+            raise RuntimeError, "File not found: #{path_and_file}" unless file_exists(path_and_file)
+            new_lines    = []
+            line_removed = false
+            read_file(path_and_file).each do |line_content|
+                line_content.gsub!(/\n\z/, '')
+                line_content_to_match = line_content.strip
+                if line_content_to_match =~ regex
+                    if multiple_occurrences
+                        next
+                    else
+                        unless line_removed
+                            line_removed = true
+                            next
+                        end
+                    end
+                end
+                new_lines << line_content
+            end
+            write_file(path_and_file, new_lines)
+        end
+
+        # Get content of a file as an "Array of Lines"
+        # @return Array
+        def self.read_file(path_and_file, start_line = nil, end_line = nil)
+            raise RuntimeError, "Expected String, instead got:#{path_and_file.class}" unless path_and_file.is_a?(String)
+            line_count    = 0
+            path_and_file = File.expand_path(path_and_file)
+            raise RuntimeError, "File not found: #{path_and_file}" unless file_exists(path_and_file)
+            raise RuntimeError, "start_line (#{start_line}) cannot be bigger than end_line (#{end_line})." if (!start_line.nil? && !end_line.nil?) && (start_line > end_line)
+            file_content = []
+            file         = File.open(path_and_file).read
+            file.gsub!(/\r\n?/, "\n")
+            file.each_line do |line|
+                line_count += 1
+                next if !start_line.nil? && start_line > line_count
+                next if !end_line.nil? && end_line < line_count
+                file_content << line
+            end
+            file_content
+        end
+
+        # Deletes a file (if exists)
+        # @return void
+        def self.delete_file(path_and_file)
+            raise RuntimeError, "Expected String, instead got:#{path_and_file.class}" unless path_and_file.is_a?(String)
+            FileUtils.rm(File.expand_path(path_and_file)) if file_exists(path_and_file)
+        end
+
+        # Returns TRUE or FALSE depending whether a path exists.
+        # @return void
+        def self.path_exists(path)
+            raise RuntimeError, "Expected String, instead got:#{path.class}" unless path.is_a?(String)
+            File.directory?(File.expand_path(path))
+        end
+
+        # Returns TRUE or FALSE depending whether a path exists.
+        # @return void
+        def self.file_exists(path_and_file)
+            raise RuntimeError, "Expected String, instead got:#{path_and_file.class}" unless path_and_file.is_a?(String)
+            File.exist?(File.expand_path(path_and_file))
+        end
+
+        # Get full path, IE: '~/Repos' would become '/Users/Albert/Repos'
+        # @return String
+        def self.get_full_path(path)
+            raise RuntimeError, "Expected String, instead got:#{path.class}" unless path.is_a?(String)
+            "/#{Blufin::Strings.remove_surrounding_slashes(File.expand_path(path))}"
+        end
+
+        # Get and array of files in a directory.
+        # @return Array
+        def self.get_files_in_dir(path, only_with_extension = nil)
+            raise RuntimeError, "Expected String, instead got:#{path.class}" unless path.is_a?(String)
+            path = "/#{Blufin::Strings.remove_surrounding_slashes(File.expand_path(path))}"
+            raise RuntimeError, "Directory doesn't exist: #{path}" unless path_exists(path)
+            files = Dir.glob("#{path}/**/*.#{only_with_extension.nil? ? '*' : only_with_extension}")
+            files.uniq.sort
+        end
+
+        # Get and array of directories in a directory.
+        # @return Array
+        def self.get_dirs_in_dir(path, recursive = false)
+            raise RuntimeError, "Expected String, instead got:#{path.class}" unless path.is_a?(String)
+            path = "/#{Blufin::Strings.remove_surrounding_slashes(File.expand_path(path))}"
+            raise RuntimeError, "Directory doesn't exist: #{path}" unless path_exists(path)
+            dirs = Dir.glob("#{path}/**/*/")
+            unless recursive
+                root_dirs   = []
+                root_length = path.split('/').length
+                dirs.each do |dir|
+                    root_dirs << dir if dir.split('/').length == root_length + 1
+                end
+                dirs = root_dirs
+            end
+            dirs.map! { |value| value.gsub(/\/\z/, '') }
+            dirs
+        end
+
+        # Create a directory recursively (if it doesn't already exist).
+        # @return String
+        def self.create_directory(path)
+            begin
+                path = File.expand_path(path)
+                FileUtils.mkpath(path) unless path_exists(path)
+                path
+            rescue => e
+                Blufin::Terminal::print_exception(e)
+            end
+        end
+
+        # Proxy function for the above.
+        # @return void
+        def self.create_path(path)
+            create_directory(path)
+        end
+
+        private
+
+        # Creates path (if not exists) and deletes file (if exists).
+        # @return void
+        def self.prepare_for_file_write(path_and_file)
+            FileUtils::mkdir_p(File.dirname(path_and_file)) unless path_exists(File.dirname(path_and_file))
+            File.delete(path_and_file) if file_exists(path_and_file)
+        end
+
+    end
+
+end