pg-verify 0.1.0

data/lib/pg-verify/core/cmd_runner.rb

@@ -0,0 +1,151 @@
+module PgVerify
+
+    module Core
+
+        module CMDRunner
+
+            # Runs the command and raises on error.
+            def self.run_cmd(cmd, env_variables = {}, include_stderr: false)
+                start_time = Time.new
+                output, err, status = Open3.capture3(env_variables, cmd)
+                delta_seconds = (Time.new - start_time).to_i
+                raise CMDRunnerError.new(cmd, output, err, delta_seconds) unless status.success?
+                return output + err if include_stderr
+                return output
+            end
+
+            # Runs the command and returns stdout on success. Returns the specified value otherwise.
+            def self.run_or_return(cmd, fail_output = nil)
+                output, err, status = Open3.capture3(cmd)
+                return status.success? ? output : fail_output
+            end
+
+            # Runs the command and returns stdout, stderr and the status.
+            # Status will be true only if the command succeeded.
+            def self.run_for_result(cmd)
+                output, err, status = run_for_result_with_plain_status(cmd)
+                return output, err, status.success?
+            end
+
+            def self.run_for_result_with_plain_status(cmd)
+                output, err, status = Open3.capture3(cmd)
+                return output, err, status
+            end
+
+            def self.run_for_exit_code(cmd)
+                output, err, status = Open3.capture3(cmd)
+                return status.exitstatus
+            end
+
+            def self.drop_into_shell()
+                shell = run_cmd("echo ${SHELL}")
+                system("#{shell}")
+            end
+
+            def self.run_in_screen(cmd, session_name)
+                run_cmd("screen -S #{session_name} -dm bash -c '#{cmd}'")
+            end
+
+            def self.run_with_timeout(cmd)
+                require 'timeout'
+                Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thread|
+                    Timeout.timeout(2) do
+                        wait_thread.join
+                    end
+                end
+            end
+
+            def self.with_drop_on_fail(shell, intent: nil, &blk)
+                begin
+                    blk.call()
+                rescue CMDRunnerError => e
+                    shell.info("Output:\n#{e.output}")
+                    shell.error("The action that was attempted did fail after #{e.delta_seconds} seconds!")
+                    shell.info("The exact command was: #{e.command.c_command}")
+                    shell.info("Intent was: #{intent}") unless intent.nil?
+                    shell.info("You can try to resolve this problem manually.")
+                    raise e unless shell.ask_confirm(nil, question: "Do you want to open a shell and try our luck?")
+                    drop_into_shell()
+                    shell.info("Welcome back :D")
+                
+                    op1 = "Run the command again to see if it works."
+                    op2 = "Just continue and pretend the command did succeed.\n(This will return '' to the caller)"
+                    op3 = "Assume the command failed."
+                    sel = shell.select([op1, op2, op3], prompt: "How shall we continue?").first
+                    case sel
+                    when op1
+                        return with_drop_on_fail(shell, blk, intent: intent,)
+                    when op2
+                        return ""
+                    when op3
+                        raise e
+                    end
+                end
+            end
+
+            # Runs the specified command and waits for it to complete. Calls the specified
+            # block for each line the process writes to stdout and err.
+            # Will return two things:
+            #   1. The complete output as a string
+            #   2. The result as a bool, where true means success.
+            # If raise_on_fail is set to true it will raise directly on fail and not return the results.
+            # If gulp_interrupt is set to true will also gulp interrupts.
+            def self.run_and_follow(cmd, raise_on_fail: true, gulp_interrupt: false, timeout: nil, &blk)
+                start_time = Time.new
+                output = ""
+                success = nil
+                
+                Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thread|
+                    begin
+                        # Listen to stdout & stderr in seperate threads.
+                        [stdout, stderr].each do |stream|
+                            Thread.new do
+                                begin
+                                    until (line = stream.gets).nil? do
+                                        blk.call(line) unless blk.nil?
+                                        output += line
+                                    end
+                                rescue IOError => e
+                                    # Expected when the stream is closed
+                                end
+                            end
+                        end
+                        unless timeout.nil?
+                            require 'timeout'
+                            Timeout.timeout(timeout) { wait_thread.join }
+                        else
+                            wait_thread.join
+                        end
+                        delta_seconds = Time.new - start_time
+                        success = wait_thread.value.success?
+                        raise CMDRunnerError.new(cmd, output, "", delta_seconds) if raise_on_fail && !success
+                    rescue SignalException => e
+                        raise e unless gulp_interrupt
+                        success = false
+                    end
+                    return output, success
+                end
+            end
+
+            def self.command_exists?(command)
+                !run_or_return("command -v '#{command}'", nil).nil?
+            end
+
+            class CMDRunnerError < PgVerify::Core::Error
+                def initialize(cmd, output, err, delta_seconds)
+                    @cmd, @output, @err, @delta_seconds = cmd, output, err, delta_seconds
+                end
+
+                def formatted()
+                    title = "Running '#{@cmd}' failed after #{@delta_seconds} seconds:"
+                    
+                    body = "$ #{@cmd.c_string} \n\n #{@err}"
+                    return title, body
+                end
+
+            end
+
+        end
+
+    end
+end

data/lib/pg-verify/core/core.rb

@@ -0,0 +1,38 @@
+module PgVerify
+
+    module Core
+
+        class Error < StandardError
+
+            def formatted()
+                raise "Not implemented in subclass #{self.class}"
+            end
+
+            def to_formatted()
+                title, body, hint = self.formatted()
+
+                message = []
+                
+                error_label = " ✖ ERROR ".bg_error
+                message << "#{error_label} #{title.c_error}" unless title.nil?
+
+                indent = "  ".bg_error + "  "
+                message << "#{indent}\n#{body.indented(str: indent)}\n#{indent}" unless body.nil?
+
+                indent = "  ".bg_warn + "  "
+                message << backtrace.map.map {|l| "#{indent}#{l.c_warn}"}.join("\n") if Settings.full_stack_trace
+
+                indent = "  ".bg_sidenote + "  "
+                message << hint.split("\n").map {|l| "#{indent}#{l.c_sidenote}"}.join("\n") unless hint.nil?
+
+                return message.join("\n")
+            end
+
+        end
+
+    end
+
+end
+
+# Require all module files
+Dir[File.join(__dir__, "**", '*.rb')].sort.each { |file| require file }

data/lib/pg-verify/core/extensions/array_extensions.rb

@@ -0,0 +1,11 @@
+class Array
+
+    def gsub(elem, substitute)
+        return self.map { |orig| orig == elem ? substitute : orig }
+    end
+
+    def blank?()
+        return empty?()
+    end
+
+end

data/lib/pg-verify/core/extensions/enumerable_extensions.rb

@@ -0,0 +1,19 @@
+module Enumerable
+
+    def powerset
+        array = self.to_a()
+        ret = Enumerator.new {|ps|
+            array.size.times {|n|
+                array.combination(n).each(&ps.method(:yield))
+            }
+        }
+        return ret.to_a + [array]
+    end
+
+    def subset?(other)
+        other = other.to_a()
+        array = self.to_a()
+        return other.all? { |item| array.include?(item) }
+    end
+    
+  end

data/lib/pg-verify/core/extensions/nil_extensions.rb

@@ -0,0 +1,7 @@
+class NilClass
+
+    def blank?()
+        true
+    end
+
+end

data/lib/pg-verify/core/extensions/string_extensions.rb

@@ -0,0 +1,84 @@
+class String
+
+    def integer?
+        self.to_i.to_s == self
+    end
+
+    def snake_case
+        self.strip()
+            .gsub(/ +/, "_")
+            .gsub(/::/, '/')
+            .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+            .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+            .tr("-", "_")
+            .downcase()
+    end
+
+    def camel_case
+        return self if self !~ /_/ && self =~ /[A-Z]+.*/
+        split('_').map{|e| e.capitalize}.join
+    end
+
+    def grep(str, e)
+        self.split("\n").select { |l| l.include?(str) }
+    end
+
+    def display_length()
+        str = PgVerify::Colorizer.uncolorize(self)
+        str.length() + ( str.count("\t") * 4 )
+    end
+
+    def line_combine(other, separator: " ")
+        PgVerify::StringUtil.line_combine(self, other, separator: separator)
+    end
+
+    def indented(num: 1, str: " " * 4)
+        PgVerify::StringUtil.indented(self, num_indents: num, indent_string: str)
+    end
+
+    def remove_before(substring)
+        split = self.split(substring)
+        return "" if split.length == 1
+        return split[1, split.length].join(substring)
+    end
+
+    def blank?
+        self.empty?
+    end
+
+    def limit_lines(num_lines, separator: "...")
+        return "" if num_lines == 0
+        split = self.split("\n")
+        return self unless split.length > num_lines
+        first_part = split[0, num_lines / 2]
+        second_part = split[split.length - (num_lines - first_part.length), split.length]
+        return first_part.join("\n") + "\n#{separator}\n" + second_part.join("\n")
+    end
+
+    def shorten(length)
+        return self if self.length <= length
+        return self[0, [length - 3, 1].max] + "..."
+    end
+
+    def labelize(bg: :darkgreen, fg: :white)
+        "◖".send(:"c_#{bg}") + " #{self} ".send(:"bg_#{bg}").send(:"c_#{fg}").c_bold + "◗".send(:"c_#{bg}")
+    end
+
+    def file?()
+        File.file?(self)
+    end
+
+    def directory?()
+        File.directory?(self)
+    end
+
+    # Support this method for Ruby <= 2.3
+    unless self.method_defined?(:delete_prefix)
+        def delete_prefix(prefix)
+            self.respond_to?(:delete_prefix)
+            return unless self.start_with?(prefix)
+            return self[prefix.length, self.length - 1]
+        end
+    end
+
+end

data/lib/pg-verify/core/shell/colorizer.rb

@@ -0,0 +1,136 @@
+require "rainbow"
+
+module PgVerify
+
+    # A Module for easy coloration of strings with theme support.
+    # After #attach is called strings can be colored using one of any c_ or bg_ methods
+    #   e.g: "Hello".c_cyan, "Hello".bg_blue
+    # Calls can also by chained:
+    #   e.g: "Hello".c_red.bg_blue.c_bold
+    #
+    # A theme is a hash of keys to values. Values can be:
+    #   1. Hex values. e.g '#00AABB'
+    #   2. Color names that are defined elswhere. e.g: 'red'
+    #   3. Arrays of values. e.g [ 'white', '_#000000', 'bold' ]
+    # If a value starts with an underscore (e.g _red) the color will
+    # be used as the background color.
+    # Strings can then be colored using the c_<key> method.
+    #   e.g: mycolor => [ "#FFFFFF", "_black" ]
+    #        mystyle => [ "mycolor", "bold" ]
+    #        "Hello".c_mystyle   <- Colored white on black in bold
+    module Colorizer
+
+        def self.send_call(rainbow, color_expr)
+            prefix = color_expr.start_with?("_") ? "bg" : "c"
+            color_expr = color_expr.sub("_", "")
+
+            # If the color expression is a HEX (e.g #FF3400) ..
+            if color_expr.start_with?("#")
+                # Send the call directly to Rainbow
+                return rainbow.send(prefix == "bg" ? :background : :color, color_expr)
+            else
+                # Otherwise forward the call
+                return rainbow.send("#{prefix}_#{color_expr}".to_sym)
+            end
+        end
+
+        def self.define_methods(hash)
+            Rainbow::X11ColorNames::NAMES.each do |color_name, _|
+                define_method "c_#{color_name}".to_sym do
+                    Rainbow(self).color(color_name.to_sym)
+                end
+                define_method "bg_#{color_name}".to_sym do
+                    Rainbow(self).send(:background, color_name)
+                end
+            end
+
+            hash.each do |key, color_names|
+                array = color_names.is_a?(Array) ? color_names : [ color_names ]
+                define_method "c_#{key}".to_sym do
+                    rainbow = Rainbow(self)
+                    array.each { |color_name|
+                        rainbow = Colorizer.send_call(rainbow, color_name)
+                    }
+                    rainbow
+                end
+                define_method "bg_#{key}".to_sym do
+                    rainbow = Rainbow(self)
+                    array.each { |color_name|
+                        rainbow = Colorizer.send_call(rainbow, "_#{color_name}")
+                    }
+                    rainbow
+                end
+            end
+        end
+
+        def self.uncolorize(string)
+            string.gsub(/\e\[([;\d]+)?m/, '')
+        end
+
+        def self.color?(string)
+            !!/\e\[([;\d]+)?m/.match(string)
+        end
+
+        def color(color)
+            method = "c_#{color}".to_sym
+            return self unless self.respond_to?(method)
+            self.send(method)
+        end
+
+        def c_bold
+            Rainbow(self).bold
+        end
+
+        def c_italic
+            Rainbow(self).italic
+        end
+
+        def c_underline
+            Rainbow(self).underline
+        end
+
+        def c_none
+            self
+        end
+
+        def color_bg(color)
+            Rainbow(self).background(color)
+        end
+
+        def color_regex(hash)
+            hash.each do |key, val|
+                self.gsub!(Regexp.new(key)) { |match|
+                    "#{match.color(val)}"
+                 }
+            end
+            self
+        end
+
+        def color_unique()
+            r, g, b = Colorizer.unique_color(self)
+            return Rainbow(self).color(r, g, b)
+        end
+
+        def bg_color_unique()
+            r, g, b = Colorizer.unique_color(self)
+            return Rainbow(self).background(r, g, b)
+        end
+
+        # def self.unique_color(string)
+        #     r = Random.new(Integer("0x#{Digest::SHA256.hexdigest(string)}"))
+        #     number = r.rand(0..360)
+        #     r, g, b = VsuColorUtil.hsl_to_rgb(number, 60, 50)
+        #     return r, g, b
+        # end
+
+        def self.attach(theme, use_colors: true)
+            define_methods(theme)
+            use_colors = Settings.use_colors
+            use_colors &&= Settings.use_colors_in_pipe if !$stdout.isatty
+            Rainbow.enabled = use_colors
+            String.class_eval { include PgVerify::Colorizer }
+        end
+
+    end
+    
+end

data/lib/pg-verify/core/util.rb

@@ -0,0 +1,146 @@
+module PgVerify
+
+
+    module TimeUtil
+
+        SECONDS_IN_SECOND = 1
+        SECONDS_IN_MINUTE = SECONDS_IN_SECOND * 60
+        SECONDS_IN_HOUR   = SECONDS_IN_MINUTE * 60
+        SECONDS_IN_DAY    = SECONDS_IN_HOUR   * 24
+        SECONDS_IN_WEEK   = SECONDS_IN_DAY    * 7
+        SECONDS_IN_MONTH  = SECONDS_IN_WEEK   * 4
+        SECONDS_IN_YEAR   = SECONDS_IN_MONTH  * 12
+
+        def self.duration_string(seconds, short: false)
+            i_seconds = seconds.to_i
+            return "~#{'%.2f' % (seconds*1000)}#{short ? "ms" : " milliseconds"}" if i_seconds == 0
+            return duration_to_h(i_seconds, short: short)
+        end
+
+        def self.duration_to_h(seconds, short: false)
+            seconds = seconds.to_i
+            {  
+                SECONDS_IN_YEAR   => ( short ? "y" : " year"   ),
+                SECONDS_IN_MONTH  => ( short ? "M" : " month"  ),
+                SECONDS_IN_WEEK   => ( short ? "w" : " week"   ),
+                SECONDS_IN_DAY    => ( short ? "d" : " day"    ),
+                SECONDS_IN_HOUR   => ( short ? "h" : " hour"   ),
+                SECONDS_IN_MINUTE => ( short ? "m" : " minute" ),
+                SECONDS_IN_SECOND => ( short ? "s" : " second" )
+            }.each do |unit_seconds, unit_string|
+                units = seconds / unit_seconds
+                unit_string = unit_string + "s" if !short && units != 1
+                return "#{units}#{unit_string} #{duration_to_h(seconds % unit_seconds, short: short)}".strip unless units == 0
+            end
+            nil
+        end
+
+        def self.ago_h(start_time, short: false)
+            duration_to_h((Time.now - start_time).to_i, short: short) + " ago"
+        end
+
+        def self.timestamp(time = Time.new)
+            return time.utc.to_i
+        end
+
+        def self.from_timestamp(ts)
+            time = Time.at(ts.to_i).utc
+            return time
+        end
+
+    end
+
+    class StringUtil
+
+        def self.make_unique(string, strings, &blk)
+            base_string = string
+            index = 0
+            while strings.include?(string)
+                index += 1
+                string = blk.call(base_string, index)
+            end
+            string
+        end
+
+        def self.limit_width(string, width)
+            return string if string.nil? || string.length <= width
+            return string.chars.each_slice(width).map(&:join).join("\n")
+        end
+
+        def self.auto_complete(string, options)
+            perfect_match = options.select { |o| o == string }.uniq
+            return perfect_match unless perfect_match.empty?
+            options.select { |o| o.start_with?(string) }.uniq
+        end
+
+        def self.levenshtein_suggest(string, options, suggestions: 5)
+            options.map { |o| [o, levenshtein_distance(string, o)] }
+                .sort_by{ |a| a[1] }
+                .vsu_limit(suggestions)
+                .map { |a| a[0] }
+        end
+
+        def self.line_combine(string1, string2, separator: " ")
+            return string2 if string1.empty?
+            lines1, lines2 = string1.split("\n"), string2.split("\n")
+            both = [lines1, lines2]
+            height  = both.map(&:length).max
+            l_width = lines1.map(&:display_length).max
+
+            # Fill up empty lines to match height
+            both.each { |lines| loop { break if lines.length >= height; lines << "" } }
+            
+            # Fill up left lines to align right side
+            lines1 = lines1.map { |l| l + " " * (l_width - l.display_length) }
+
+            # Combine left and right.
+            string = (0...height).map { |index|
+                lines1[index] + separator + lines2[index]
+            }.join("\n")
+
+            return string
+        end
+
+        def self.shorten_unique(strings)
+            # TODO: Implement
+            return strings.each_with_index.map { |s, i| [s, i.to_s] }.to_h
+           
+            # chars = ".- _".chars
+            # regex = /#{chars.map { |c| "\\#{c}" }.join("|")}/
+            # map = {}
+            # strings.each do |str|
+            #     index = 0
+            #     loop do 
+            #         split = str.gsub(regex, " ").split
+            #         short = split.map { |word| word[0, index] }.join("")
+            #         puts short
+            #         sleep(1)
+            #         next if map.values.include?(short)
+            #         map[str] = short
+            #         break
+            #     end
+                
+            # end
+
+            # map
+        end
+
+        def self.indented(string, num_indents: 1, indent_string: "\t")
+            string.split("\n").map { |l| "#{indent_string * num_indents}#{l}" }.join("\n")
+        end
+
+        def self.levenshtein_distance(a, b)
+            a, b = a.downcase, b.downcase
+            costs = Array(0..b.length) # i == 0
+            (1..a.length).each do |i|
+                costs[0], nw = i, i - 1  # j == 0; nw is lev(i-1, j)
+                (1..b.length).each do |j|
+                    costs[j], nw = [costs[j] + 1, costs[j-1] + 1, a[i-1] == b[j-1] ? nw : nw + 1].min, costs[j]
+                end
+            end
+            costs[b.length]
+        end
+
+    end
+
+end