rbbt-util 5.44.1 → 6.0.3

data/lib/rbbt/util/misc/exceptions.rb

@@ -1,113 +1,118 @@
-class RbbtException < StandardError; end
-class ParameterException < RbbtException; end
-
-class MissingParameterException < ParameterException
-  def initialize(parameter)
-    super("Missing parameter '#{parameter}'")
-  end
-end
-
-class FieldNotFoundError < StandardError;end
+require_relative '../../refactor'
+Rbbt.require_instead 'scout/exceptions'
 class ClosedStream < StandardError; end
-
-class ProcessFailed < StandardError; 
-  attr_accessor :pid, :msg
-  def initialize(pid = Process.pid, msg = nil)
-    @pid = pid
-    @msg = msg
-    if @pid
-      if @msg
-        message = "Process #{@pid} failed - #{@msg}"
-      else
-        message = "Process #{@pid} failed"
-      end
-    else
-      message = "Failed to run #{@msg}"
-    end
-    super(message)
-  end
-end
-
-class SSHProcessFailed < StandardError
-  attr_accessor :host, :cmd
-  def initialize(host, cmd)
-    @host = host
-    @cmd = cmd
-    message = "SSH server #{host} failed cmd '#{cmd}'" 
-    super(message)
-  end
-end
-
-class ConcurrentStreamProcessFailed < ProcessFailed
-  attr_accessor :concurrent_stream
-  def initialize(pid = Process.pid, msg = nil, concurrent_stream = nil)
-    super(pid, msg)
-    @concurrent_stream = concurrent_stream
-  end
-end
-
-class Aborted < StandardError; end
-
-class TryAgain < StandardError; end
-
-class TryThis < StandardError
-  attr_accessor :payload
-  def initialize(payload = nil)
-    @payload = payload
-  end
-end
-
-class SemaphoreInterrupted < TryAgain; end
-class LockInterrupted < TryAgain; end
-
-class RemoteServerError < StandardError; end
-
-class DependencyError < Aborted
-  def initialize(msg)
-    if defined? Step and Step === msg
-      step = msg
-      new_msg = [step.path, step.messages.last] * ": "
-      super(new_msg)
-    else
-      super(msg)
-    end
-  end
-end
-
-class DependencyRbbtException < RbbtException
-  def initialize(msg)
-    if defined? Step and Step === msg
-      step = msg
-
-      new_msg = nil
-      new_msg = [step.path, step.messages.last] * ": "
-
-      super(new_msg)
-    else
-      super(msg)
-    end
-  end
-end
-
-class DontClose < Exception; end
-
-class KeepLocked < Exception
-  attr_accessor :payload
-  def initialize(payload)
-    @payload = payload
-  end
-end
-
-class KeepBar < Exception
-  attr_accessor :payload
-  def initialize(payload)
-    @payload = payload
-  end
-end
-
-class StopInsist < Exception
-  attr_accessor :exception
-  def initialize(exception)
-    @exception = exception
-  end
-end
+RbbtException = ScoutException
+#class RbbtException < ScoutException; end
+#class ParameterException < RbbtException; end
+#
+#class MissingParameterException < ParameterException
+#  def initialize(parameter)
+#    super("Missing parameter '#{parameter}'")
+#  end
+#end
+#
+#class FieldNotFoundError < StandardError;end
+#class ClosedStream < StandardError; end
+#
+#class ProcessFailed < StandardError; 
+#  attr_accessor :pid, :msg
+#  def initialize(pid = Process.pid, msg = nil)
+#    @pid = pid
+#    @msg = msg
+#    if @pid
+#      if @msg
+#        message = "Process #{@pid} failed - #{@msg}"
+#      else
+#        message = "Process #{@pid} failed"
+#      end
+#    else
+#      message = "Failed to run #{@msg}"
+#    end
+#    super(message)
+#  end
+#end
+#
+#class SSHProcessFailed < StandardError
+#  attr_accessor :host, :cmd
+#  def initialize(host, cmd)
+#    @host = host
+#    @cmd = cmd
+#    message = "SSH server #{host} failed cmd '#{cmd}'" 
+#    super(message)
+#  end
+#end
+#
+#class ConcurrentStreamProcessFailed < ProcessFailed
+#  attr_accessor :concurrent_stream
+#  def initialize(pid = Process.pid, msg = nil, concurrent_stream = nil)
+#    super(pid, msg)
+#    @concurrent_stream = concurrent_stream
+#  end
+#end
+#
+#class Aborted < StandardError; end
+#
+#class TryAgain < StandardError; end
+#
+#class TryThis < StandardError
+#  attr_accessor :payload
+#  def initialize(payload = nil)
+#    @payload = payload
+#  end
+#end
+#
+#class SemaphoreInterrupted < TryAgain; end
+#class LockInterrupted < TryAgain; end
+#
+#class RemoteServerError < StandardError; end
+#
+#class DependencyError < Aborted
+#  def initialize(msg)
+#    if defined? Step and Step === msg
+#      step = msg
+#      new_msg = [step.path, step.messages.last] * ": "
+#      super(new_msg)
+#    else
+#      super(msg)
+#    end
+#  end
+#end
+#
+#class DependencyException < RbbtException
+#class DependencyRbbtException < RbbtException
+#  def initialize(msg)
+#    if defined? Step and Step === msg
+#      step = msg
+#
+#      new_msg = nil
+#      new_msg = [step.path, step.messages.last] * ": "
+#
+#      super(new_msg)
+#    else
+#      super(msg)
+#    end
+#  end
+#end
+#
+#class DontClose < Exception; end
+#
+#class KeepLocked < Exception
+#  attr_accessor :payload
+#  def initialize(payload)
+#    @payload = payload
+#  end
+#end
+#
+#class KeepBar < Exception
+#  attr_accessor :payload
+#  def initialize(payload)
+#    @payload = payload
+#  end
+#end
+#
+#class StopInsist < Exception
+#  attr_accessor :exception
+#  def initialize(exception)
+#    @exception = exception
+#  end
+#end

data/lib/rbbt/util/misc/format.rb

@@ -1,230 +1,2 @@
-module Misc
-  COLOR_LIST = %w(#BC80BD #CCEBC5 #FFED6F #8DD3C7 #FFFFB3 #BEBADA #FB8072 #80B1D3 #FDB462 #B3DE69 #FCCDE5 #D9D9D9)
-
-  def self.colors_for(list)
-    unused = COLOR_LIST.dup
-
-    used = {}
-    colors = list.collect do |elem|
-      if used.include? elem
-        used[elem]
-      else
-        color = unused.shift
-        used[elem]=color
-        color
-      end
-    end
-
-    [colors, used]
-  end
-
-  def self.format_seconds(time, extended = false)
-    seconds = time.to_i
-    str = [seconds/3600, seconds/60 % 60, seconds % 60].map{|t|  "%02i" % t }.join(':')
-    str << ".%02i" % ((time - seconds) * 100) if extended
-    str
-  end
-
-  def self.format_paragraph(text, size = 80, indent = 0, offset = 0)
-    i = 0
-    offset = 0 if offset.nil?
-    indent = 0 if indent.nil?
-    size = 80 if size.nil?
-    size = size + offset + indent
-    re = /((?:\n\s*\n\s*)|(?:\n\s*(?=\*)))/
-      text.split(re).collect do |paragraph|
-      i += 1
-      str = if i % 2 == 1
-              words = paragraph.gsub(/\s+/, "\s").split(" ")
-              lines = []
-              line = " "*offset
-              word = words.shift
-              while word
-                word = word[0..size-indent-offset-4] + '...' if word.length >= size - indent - offset
-                while word and Log.uncolor(line).length + Log.uncolor(word).length <= size - indent
-                  line << word << " "
-                  word = words.shift
-                end
-                offset = 0
-                lines << ((" " * indent) << line[0..-2])
-                line = ""
-              end
-              (lines * "\n")
-            else
-              paragraph
-            end
-      offset = 0
-      str
-      end*""
-  end
-
-  def self.format_definition_list_item(dt, dd, size = 80, indent = 20, color = :yellow)
-    dd = "" if dd.nil?
-    dt = Log.color color, dt if color
-    dt = dt.to_s  unless dd.empty?
-    len = Log.uncolor(dt).length
-
-    if indent < 0
-      text = format_paragraph(dd, size, indent.abs-1, 0)
-      text = dt << "\n" << text
-    else
-      offset = len - indent
-      offset = 0 if offset < 0
-      text = format_paragraph(dd, size, indent.abs+1, offset)
-      text[0..len-1] = dt
-    end
-    text
-  end
-
-  def self.format_definition_list(defs, size = 80, indent = 20, color = :yellow, sep = "\n\n")
-    entries = []
-    defs.each do |dt,dd|
-      text = format_definition_list_item(dt,dd,size,indent,color)
-      entries << text
-    end
-    entries * sep 
-  end
-
-  def self.camel_case(string)
-    return string if string !~ /_/ && string =~ /[A-Z]+.*/
-      string.split(/_|(\d+)/).map{|e| 
-        (e =~ /^[A-Z]{2,}$/ ? e : e.capitalize) 
-      }.join
-  end
-
-  def self.camel_case_lower(string)
-      string.split('_').inject([]){ |buffer,e| 
-        buffer.push(buffer.empty? ? e.downcase : (e =~ /^[A-Z]{2,}$/ ? e : e.capitalize)) 
-      }.join
-  end
-
-  def self.snake_case(string)
-    return nil if string.nil?
-    string = string.to_s if Symbol === string
-    string.
-      gsub(/([A-Z]{2,})([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z])([A-Z])/,'\1_\2').
-      gsub(/\s/,'_').gsub(/[^\w_]/, '').
-      split("_").collect{|p| p.match(/[A-Z]{2,}/) ? p : p.downcase } * "_"
-  end
-
-  # source: https://gist.github.com/ekdevdes/2450285
-  # author: Ethan Kramer (https://github.com/ekdevdes)
-  def self.humanize(value, options = {})
-    if options.empty?
-      options[:format] = :sentence
-    end
-
-    values = value.to_s.split('_')
-    values.each_index do |index|
-      # lower case each item in array
-      # Miguel Vazquez edit: Except for acronyms
-      values[index].downcase! unless values[index].match(/[a-zA-Z][A-Z]/)
-    end
-    if options[:format] == :allcaps
-      values.each do |value|
-        value.capitalize!
-      end
-
-      if options.empty?
-        options[:seperator] = " "
-      end
-
-      return values.join " "
-    end
-
-    if options[:format] == :class
-      values.each do |value|
-        value.capitalize!
-      end
-
-      return values.join ""
-    end
-
-    if options[:format] == :sentence
-      values[0].capitalize! unless values[0].match(/[a-zA-Z][A-Z]/)
-
-      return values.join " "
-    end
-
-    if options[:format] == :nocaps
-      return values.join " "
-    end
-  end
-
-  def self.fixascii(string)
-    if string.respond_to?(:encode)
-      self.fixutf8(string).encode("ASCII-8BIT") 
-    else
-      string
-    end
-  end
-
-  def self.to_utf8(string)
-    string.encode("UTF-16BE", :invalid => :replace, :undef => :replace, :replace => "?").encode('UTF-8')
-  end
-
-  def self.fixutf8(string)
-    return nil if string.nil?
-    return string if string.respond_to?(:encoding) && string.encoding.to_s == "UTF-8" && (string.respond_to?(:valid_encoding?) && string.valid_encoding?) ||
-                     (string.respond_to?(:valid_encoding) && string.valid_encoding)
-
-    if string.respond_to?(:encode)
-      string.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
-    else
-      require 'iconv'
-      @@ic ||= Iconv.new('UTF-8//IGNORE', 'UTF-8')
-      @@ic.iconv(string)
-    end
-  end
-
-  def self.humanize_list(list)
-    return "" if list.empty?
-    if list.length == 1
-      list.first
-    else
-      list[0..-2].collect{|e| e.to_s} * ", " << " and " << list[-1].to_s
-    end
-  end
-
-  def self.parse_sql_values(txt)
-    io = StringIO.new txt.strip
-
-    values = []
-    fields = []
-    current = nil
-    quoted = false
-    while c = io.getc
-      if quoted
-        if c == "'"
-          quoted = false
-        else
-          current << c
-        end
-      else
-        case c
-        when "("
-          current = ""
-        when ")"
-          fields << current
-          values << fields
-          fields = []
-          current = nil
-        when ','
-          if not current.nil?
-            fields << current
-            current = ""
-          end
-        when "'"
-          quoted = true
-        when ";"
-          break
-        else
-          current << c
-        end
-      end
-    end
-    values
-  end
-
-end
+require_relative 'refactor'
+Rbbt.require_instead 'scout/misc/format'

data/lib/rbbt/util/misc/indiferent_hash.rb

@@ -1,107 +1,2 @@
-module IndiferentHash
-
-  def self.setup(hash)
-    hash.extend IndiferentHash 
-  end
-
-  def merge(other)
-    new = self.dup
-    IndiferentHash.setup(new)
-    other.each do |k,value|
-      new[k] = value
-    end
-    new
-  end
-
-  def []=(key,value)
-    delete(key)
-    super(key,value)
-  end
-
-  def _default?
-    @_default ||= self.default or self.default_proc
-  end
-
-  def [](key, *args)
-    res = super(key, *args) 
-    res = IndiferentHash.setup(res) if Hash === res
-    return res unless res.nil? or (_default? and not keys.include? key)
-
-    case key
-    when Symbol, Module
-      res = super(key.to_s, *args)
-    when String
-      res = super(key.to_sym, *args)
-    end
-
-    res = IndiferentHash.setup(res) if Hash === res
-
-    res
-  end
-
-  def values_at(*key_list)
-    key_list.inject([]){|acc,key| acc << self[key]}
-  end
-
-  def include?(key)
-    case key
-    when Symbol, Module
-      super(key) || super(key.to_s)
-    when String
-      super(key) || super(key.to_sym)
-    else
-      super(key)
-    end
-  end
-
-  def delete(key)
-    case key
-    when Symbol, Module
-      super(key) || super(key.to_s)
-    when String
-      super(key) || super(key.to_sym)
-    else
-      super(key)
-    end
-  end
-
-  def clean_version
-    clean = {}
-    each do |k,v|
-      clean[k.to_s] = v unless clean.include? k.to_s
-    end
-    clean
-  end
-end
-
-module CaseInsensitiveHash
-  
-
-  def self.setup(hash)
-    hash.extend CaseInsensitiveHash
-  end
-
-  def downcase_keys
-    @downcase_keys ||= begin
-                         down = {} 
-                         keys.collect{|key| 
-                           down[key.to_s.downcase] = key 
-                         }
-                         down
-                       end
-  end
-
-  def [](key, *rest)
-    value = super(key, *rest)
-    return value unless value.nil?
-    key_downcase = key.to_s.downcase
-    super(downcase_keys[key_downcase])
-  end
-
-  def values_at(*keys)
-    keys.collect do |key|
-      self[key]
-    end
-  end
-  
-end
+require_relative '../../refactor'
+Rbbt.require_instead 'scout/indiferent_hash'