sakuric 2.0.1

data/lib/classes/debug_ric.rb

@@ -0,0 +1,196 @@
+
+
+# copied from Mixins in Programming ruby book, pag 119
+
+module RicDebug
+  puts "DEBUG: including module RicDebug, as a mixin within #{self.class}"
+
+  def whoami?
+    "#{self.class.name} (\##{self.object_id}): #{self}"
+  end
+
+  def trace()
+    puts "== Riccardo Debug Trace program (excuse verboity) =="
+    puts "File: #{__FILE__}"
+    #TODO put verbose context like call stack, ...  
+  end
+
+  def to_verbose_s()
+    whoami?
+  end
+end
+
+
+
+################################################################################################################
+# DEBUG AND ERRORS
+################################################################################################################
+
+$_debug_tags = []
+
+=begin
+  
+  This is a denbug with steroids
+
+  Introduced tags: NORMAL deb() works.
+  If you launch debug_on('reason', :tags => [ :this, :foo, :bar])
+  from this moment on normal debug is prevented unless you debug using the explicit tags..
+
+  Il vecchio debug era:
+  debug (s, :really_write => true,:write_always => false ) 
+
+=end
+
+def debug(s, opts = {} )
+  out = opts.fetch(:out, $stdout)
+  tag = opts.fetch(:tag, '_DFLT_')
+  really_write = opts.fetch(:really_write, true) # you can prevent ANY debug setting this to false
+  write_always = opts.fetch(:write_always, false)
+
+  raise "ERROR: ':tags' must be an array in debug(), maybe you meant to use :tag?" if ( opts[:tags] && opts[:tags].class != Array )
+  final_str = "#RDeb#{write_always ? '!' : ''}[#{opts[:tag] || '-'}] #{s}"
+  final_str = "\033[1;30m" +final_str + "\033[0m" if opts.fetch(:coloured_debug, true) # color by gray by default
+  if (debug_tags_enabled? ) # tags
+    puts( final_str ) if debug_tag_include?( opts )
+  else # normal behaviour: if NOT tag
+    puts( final_str ) if ((really_write && $DEBUG) || write_always) && ! opts[:tag]
+  end
+end #/debug()
+alias :deb :debug
+
+def debug_tags_enabled?
+  $_debug_tags != []
+end
+
+def debug_tag_include?(opts)
+  assert_array($_debug_tags, 'debug_tags')
+  assert_class( opts[:tag], Symbol, "tag must be a symbol, ", :dontdie => true ) if opts[:tag]
+  assert_array( opts[:tags] , 'opts[:tags]' ) if opts[:tags]
+  return $_debug_tags.include?(opts[:tag].to_sym) if opts[:tag]
+  return ($_debug_tags & opts[:tags]).size > 0    if opts[:tags]
+  #return $_debug_tags.include?(tag_or_tags.to_sym) if (tag.class == String || tag.class == Symbol)
+  return false
+end
+
+
+def debug_on(comment="enabling debug (SVNID=#{$SVN_ID rescue 'ERR'})", opts={} )
+  $DEBUG = true
+  deb "debug_on(): #{comment}"
+  _manage_debug_tags(opts)
+  if opts[:tags]
+    deb "debug_on(): new tags enabled (#{opts[:tags]}). Now ONLY debug called explicitly with one of those tags will work! To go back to normal behaviour just run: 'debug_reset_tags()'"
+  end
+end 
+def debug_off(comment="Disabling DEBUG for once in a while :)", opts={})
+  deb "debug_off(): #{comment}" 
+  $DEBUG = false 
+end
+
+def debug_tags
+  $_debug_tags
+end
+def debug_reset_tags
+  $_debug_tags = []
+end
+def deb2(str)
+  debug "(ERR) #{str}", :out => $stderr, :tag => 'stderr' # , :really_write => true,:write_always => false,
+end
+def stradebug(str)
+  deb str, :tags => %w(verbose stradebug vvv)
+end
+alias :stradeb :stradebug
+
+##################### 
+# All the foloowing has been transferred to 'ric' gem
+# to be removed in the future..
+
+# if DEBUG is true, then execute the code
+def deb?() 
+	yield if $DEBUG
+end
+alias :if_deb  :deb?
+alias :if_deb? :deb?
+
+def debug?()
+  $DEBUG == true
+end
+
+def debo(obj)
+  deb "debo: #{obj.ispeziona}"
+end
+
+def err(str)
+	$stderr.puts "ERR[RicLib] #{$0}: '#{str}'"
+end
+
+def fatal(ret,str)
+	err "#{get_red 'RubyFatal'}(#{ret}) #{str}"
+	exit ret
+end
+
+def warning(s)
+	err "#{yellow 'WARN'} #{s}"
+end 
+
+#def d()
+#  flag( "Cielcio (TBS arlecchinami di colori)", 'it')
+#end
+#def tbd(comment="TODO")
+#  puts "#{white :TBD} (#{__FILE__}:#{__LINE__}): #{comment}"
+#  raise "TBD_EXCEPTION! ''#{comment}''"
+#end
+
+# copiato da: 
+# http://stackoverflow.com/questions/622324/getting-argument-names-in-ruby-reflection
+$shadow_stack = []
+
+set_trace_func( lambda {
+  |event, file, line, id, binding, classname|
+  if event == "call"
+    $shadow_stack.push( eval("local_variables", binding) )
+  elsif event == "return"
+    $shadow_stack.pop
+  end
+} )
+
+def obsolete(msg)
+  puts "#{pink '_OBSOLETE_'} (#{file_line}): #{red msg}"
+  #deb "TBD dammi la traccia chiamante, cazzo! Local functions: #{eval( 'local_variables') }"
+  pgray("Obsolescense:\n -- " + caller().join("\n -- "))
+end
+
+# copiato da qui: http://www.caliban.org/ruby/rubyguide.shtml#style
+def silently(&block)
+  deb( "[DEBUG] Calling silently! warn_level is '#{$VERBOSE}'" )
+  warn_level = $VERBOSE
+  $VERBOSE = nil
+  result = block.call
+  $VERBOSE = warn_level
+  result
+end
+
+  # TBD sposta in altro file
+class RicException < Exception
+  attr_reader :description, :options
+  
+  def initialize(str,opts={})
+    description = str
+    opts = options
+    super(str)
+  end
+  
+  def to_s
+    "Ric_Exception (figata direi!): '''#{red description}'''"
+  end
+end  #/RicException
+
+private
+  def _manage_debug_tags(opts)
+    #puts "_manage_debug_tags: #{opts}"
+    $_debug_tags ||= []
+    $_debug_tags += opts[:tags] if opts[:tags]
+    #$_debug_tags << opts[:tag]  if opts[:tag]
+    $_debug_tags = $_debug_tags.uniq
+    #puts "$_debug_tags: #{$_debug_tags} (#{$_debug_tags.map{|x| x.class}})"
+    deb "_manage_debug_tags(): new tags are: #{$_debug_tags}", :tag => :debug
+  end

data/lib/classes/fake_data.rb

@@ -0,0 +1,8 @@
+
+################################################################################
+  # fake data for some tests :)
+ #$a = [1 ,2 ,3, '4', 'cinque', :simbolo ] rescue nil
+ #$h = { :key => 'value', :answer => 42 , 'float' => 4.2 , :sym => 'bol', :foo => 'bar1 (symbol)', "foo" => 'bar2 (symbol)' } # rescue nil
+ #$s = "This is a test string with some color TBD and some @tags @personal ok?!?"
+  
+

data/lib/classes/ricconf.rb

@@ -0,0 +1,110 @@
+  # $Id$
+
+=begin
+  Nella mia mente malvagia e maliziosa, questa classe dovrebbe contenere tutta la mia configurazione...
+  Meglio una classe che un insieme di metodi a cazzo di cane, che dici? La uso piu' per scope (protezione/namespace)
+  che per ereditarieta' e menate varie... vorrei poter dire: RicConf.inspect e avere tutto il buridone di configurazione
+  e null'altro...
+=end
+
+$RIC_SVNUSER ||= 'riccardo'
+# TODO9 questa variabile a tendere dovrebbe essere distrutta e sostituita da $prog_conf nel programma devel..
+$devel_conf = YAML.load(File.read("#{$SAKURADIR}/etc/sakura/devel.yml")) # dato che ci accedo da devel.rb
+
+def ric_services
+  sane_service_regex = /^[a-z_\.-]+$/
+  arr_services = [
+     hostconf('services') , # .split(',').trim_all,  # host_services = 
+     networkconf('services'), # .split(',').trim_all ,
+  ] rescue [ "Eccezione: #{$!}" ]
+  deb arr_services
+  return arr_services.compact.flatten.join(',').split(',').trim_all.select{|srv| 
+		# TODO rimuovi le right vuote
+		# next if srv == ''
+    ok = srv.match(sane_service_regex) 
+    deb("ricconf.rb:#{__LINE__} Beware, illegal service here: ''#{red srv}'' (services: #{gray arr_services.join(', ')})") unless ok
+    ok
+  }
+end
+
+
+class RicConf
+  attr_accessor :ver, :home, :user, :svn, :nreloads, :path
+  $obsolete_tags = %w{ sobenme sobenme_services sobenme_tags hea lavoro SobenmeGlobalConfDistObsolete }
+  
+  def initialize()
+    #puts "DEB RicConf::initialize(): Initializing a new #{self.class}"
+    self.ver      = $RICLIB_VERSION
+    self.home     = $HOME
+    self.user     = $USER || get_username # = 'riccardo'
+    self.path     = ENV['PATH'].split(':').uniq.sort # = 'riccardo'
+    self.svn      = ENV['SVNRIC'] 
+    self.nreloads ||= 0
+    self.nreloads += 1   # lo riassegna quindi vale sempre uno a ogni costruzione..
+  end
+  
+  def to_s
+    "RicConf: #{yellow self.inspect}"
+  end
+  
+  # after migration svn!
+  def SVNRIC
+    File.expand_path(ENV['SVNRIC'] || "~/git/gic" ) 
+  end
+  
+    # x is a string
+  def cool_eval(x)
+    y = (eval(x.to_s)) rescue "CoolEvalEsception: '#{$!}'"
+    deb "CoolEval('#{yellow x}' (#{x.class})) --> ''#{azure(y)}'' (class=#{y.class})"
+    return y
+  end
+  
+  def get_tags()
+    deb "$network_conf is a #{$network_conf.class}"
+    deb "$host_conf is a #{$hostconf.class}"
+    [ '$host_conf', '$network_conf', '2+3', 'RicConf' ].each{|var| 
+      # x = 'var.inspect()'
+      #       y = eval(x)
+      #       deb "Supercool: Evaluing('#{x}') for #{blue var} (#{var.class}) --> #{azure(y)} (class=#{y.class})"
+      cool_eval(var)
+    }
+   # my_network_tags = $network_conf['tags'] rescue []
+    tags = { 
+    #  :conf_network => my_network_tags.split(',') ,
+      :ENV_TAGS     => ENV['HOST_TAGS'].split(','),
+      :ENV_SRVS     => ENV['HOST_SERVICES'].split(','),
+    }
+    tags[:conf_host]    = $host_conf['tags'].split(',') rescue [] # fatal("Conf missing for this host: #{$!}")
+    tags[:conf_network] = $network_conf['tags'] .split(',') rescue [] # fatal("Conf missing for this host: #{$!}")
+    tags.each{|k,v|
+      deb "#{k}: #{v}"  
+    }
+    cleanup_tags = tags.values.flatten.compact.map{|x| x.strip }.uniq.sort
+    deb tags.inspect
+    # obsolete tags:
+    my_obsolete_tags =  cleanup_tags & $obsolete_tags 
+    deb "#Obsolete tags: #{red(my_obsolete_tags.map{|tag| "'#{tag}' from #{tags.map{|k,v| k if v.match(tag) }.compact }"}) }"
+    return cleanup_tags - $obsolete_tags
+  end
+  
+end # /RicConf
+
+def get_username
+  $USER ||= `whoami`.strip
+end
+alias :username :get_username
+
+def get_tags()
+  RicConf.new.get_tags
+end
+
+# Terminal stuff
+def supports_64k_colors?
+  good_terminals = %w{ iTerm.app } # these support 64k, i.e. orange
+  bad_terminals = %w{ Apple_Terminal }  # these support only 16 colors, i.e. red
+  my_terminal = ENV['TERM_PROGRAM'].to_s
+  return true if good_terminals.include?(my_terminal)
+  return false if bad_terminals.include?(my_terminal)
+  raise "Unknown terminal #{red my_terminal.quote}, please define me in: #{yellow __FILE__}"
+  return nil
+end

data/lib/classes/richelp.rb

@@ -0,0 +1,70 @@
+
+module RicHelpModule
+
+  $HELP_DIR =  "#{$SAKURADIR}/doc/richelp/"
+
+  def helpfile_parse(helpfile_name)
+    err = ''
+    helpfile = helpfile_name 
+    helpfile += ".yml" unless helpfile_name.match( /.yml$/ )
+    helpfile = "#{$HELP_DIR}/#{helpfile}" unless  helpfile.match(/\//) # has a slash
+    conf = YAML.load_file(helpfile) rescue exception_yml($!)
+    err = $!
+    deb("_conf: " + conf['_conf'].inspect)
+    $color_title      = conf['_conf']['colors']['title']    rescue "azure" 
+    $color_line_key   = conf['_conf']['colors']['line_key'] rescue "blue" 
+    $color_line_val   = conf['_conf']['colors']['line_val'] rescue 'lgray'
+    deb [  $color_title ,  $color_line_key ,   $color_line_val   ]
+    return conf unless conf.nil? 
+    return { 'Some error' => { 'parsing YML file' => "'#{$!}'" , "11" => 2 } }
+  end
+
+  def show_help(query_str)
+    n=0
+    $help_opt.each{ |menu_title,submenu|
+      next if special_help_title?(menu_title)
+      n += 1
+      if (! query_str.nil? ) # searching for sth
+        # foreach (father, sons)I have to visualize ALL sons and the matching father if and only if:
+        # 1. father string matches , OR
+        # 2. at least ONE son matches
+        # if father matches, I give ALL sons. If father doesnt, I publish the father with ONLY the matching sons :)
+        ret_search = ret_all = ''
+        submenu.each{ |k,v|
+          ret_search += help(k,v,query_str).to_s
+          ret_all    += help(k,v,'')
+        }
+        father_matches = menu_title.match(query_str)
+        sons_match = ret_search.length > 0 
+        if (father_matches || sons_match)
+          title("#{n}. #{menu_title.capitalize}")  
+          puts father_matches ? ret_all : ret_search
+        end
+      else # no searching: visualizing everything
+        #puts "Querystring: #{query_str} (#{query_str.length})"
+        title("#{n}. #{menu_title.capitalize}") 
+        submenu.each{ |k,v|
+           puts help(k,v,query_str)
+        }
+      end
+    }
+  end
+
+  def sanitize_help_file(file_str)
+    file_str = file_str.gsub(/\.yml$/,'')  
+    File.expand_path "#{$HELP_DIR}/#{file_str}.yml"
+  end
+
+  def show_test(file_str)
+    file = sanitize_help_file(file_str)
+    hash_or_errorstring = YAML.load_file( file ) rescue "#{$!}"
+    if hash_or_errorstring.class == Hash
+      puts "OK File yml: #{green file}"
+      exit 0
+    else
+      puts "Some problems with '#{file}': #{red hash_or_errorstring}"
+      exit 78
+    end
+  end
+
+end

data/lib/classes/strings.rb

@@ -0,0 +1,284 @@
+#!/usr/bin/env ruby
+
+class String
+  include RicDebug
+
+  def basename
+    split('/').last
+  end
+  
+  def left(length,padding)
+    mylen = self.length
+    padding_char = padding[0] # troppo difficile fare che paddi "abc" su 8 fa "abcabcab" checcavolo :)
+    mylen < length ?
+      self + padding * (length - mylen) :
+      self 
+  end
+  
+  def color(mycolor = :orange )
+    send(mycolor,self)
+  end
+  
+  def uncolor()
+    scolora(self)
+  end
+  
+		# trovata qui: la mia funziona cmq
+	# http://www.ruby-forum.com/topic/96222
+	def to_class
+		Object.const_get(self)
+		#ret = eval(self)
+		#deb "this is a class? cls=#{ret.class}"
+		#raise "Exception its not a class!" if ret.class.to_s != 'Class'
+		#return ret
+	end
+
+  def nlines
+    split("\n").size
+  end
+  
+    # rimuove spazi a inizio e fine
+  def trim
+    self.gsub(/^\s+/,'').gsub(/\s+$/,'')
+  end
+  
+  def escape_printf
+     gsub("%",'%%')
+  end
+  
+  def escape_double_quotes
+    gsub('"','\"')
+  end
+  def escape_single_quotes
+    gsub("'","\'")
+  end
+  
+  # dumps string to file (in APPEND) :)
+  def tee(opts={})
+    filename = opts.fetch :file, __FILE__ + ".tmpric"
+    verbose  = opts.fetch :verbose,  true
+    preamble = lambda {|where| return "# Teeing string (pid=#{$$}, size=#{self.size}B, opts=#{opts}) into file: #{blue filename}\n" }
+    deb "Teeing string (#{self.size}B, opts=#{opts}) into file: #{blue filename}"
+    File.open(filename, 'a') {|f|
+      f.write("# {{{  String.tee #{} from #{__FILE__}\n") if verbose
+      f.write(preamble.call(:BEGIN)) if verbose
+      f.write(self)
+      f.write("\n" + preamble.call(:END))if verbose
+      f.write("\n# }}} Tee stop pid=##{$$}\n")if verbose
+    } # i think it closes it here...
+    puts "Written #{self.size}B in append to: '#{yellow filename}'" if verbose
+    return self
+  end
+
+=begin
+  return string with regex highlighted
+  
+  TODO highlight just the matching regex
+=end
+  def grep_color(regex, opts={} )
+    deb "string grep_color(regex: '#{regex}')"
+    color   = opts[:color]   || true # false
+    verbose = opts[:verbose] || true # TODO false
+    return red(self) if self.match(regex)
+    return verbose ?
+      self :
+      ''
+  end
+  
+  # Doesnt work. Look at ~/bin/uptimes for a VERY nice implementation
+  # def color_grep(regex, mycolor, opts={} )
+  #   #deb "string grep_color(regex: '#{regex}' w/ color='#{mycolor}')"
+  #   color   = opts[:color]   || true # false
+  #   return self.gsub(regex, $1.color(mycolor)) if self.match(regex)
+  #   return self
+  # end
+  
+  alias :right :left
+  
+  def flag(nation)
+    flag(self, flag = '')
+  end
+  
+    # enclose string in single quotes..
+  def quote(sep = nil)
+    sep ||= "'"
+    sep + self + sep
+  end
+  def double_quote(); quote('"') ; end
+  
+  def depurate_for_file 
+    gsub(/[\/: \.]/ , '_')
+  end
+
+  def prepend(str)
+    str.to_s+self
+  end
+  def append(str)
+    self+str.to_s
+  end
+  
+  # a: b
+  # c: d 
+  # --> 
+  def to_hash(description='String::to_hash() made by genious RCarlesso (give a better description if u dont like this!)')
+    arr = Hash.new
+    arr['_meta']  = Hash.new
+    arr['_meta']['description'] = description
+    arr['_meta']['time'] = Time.now
+    self.split("\n").each{|line| 
+      k,v = line.split(': ') 
+      arr[k.strip] = v.strip 
+      } rescue arr['_meta']['errors'] = $! 
+    arr
+  end
+  
+  def starts_with?(ch)
+    self.match(/^#{ch}/)
+  end
+  
+    # 'abcde' => '*****'
+  def asterisks(ch='*')
+    ch * (self.size)
+  end
+  
+  def shorten (count = 50)
+     if self.length >= count
+       shortened = self[0, count]
+       splitted = shortened.split(/\s/)
+       words = splitted.length
+       splitted[0, words-1].join(" ") + ' ...'
+     else
+       self
+     end
+   end
+#   alias :excerpt :shorten
+# no dai, in realta excerpt sarebbe con SEARCH di parola e ci orla intorno...
+
+  # sanitizza un filename
+  def sanitize_path
+    gsub(/[\/: ]/,'_')
+  end
+
+  # see arrays!
+  # def method_missing
+  # end
+  
+  def to_html
+    %(<span class="ricsvn_string" >#{self}</span>)
+  end
+  
+  def initial;  self[0..0] ; end 
+  
+  
+  # canonicalize: delete leading and trailing spaces, replaces newlines
+  # with one space and then replace all continuouse spaces with one ' '
+  # (including tabs and other fancy things)
+  
+  # non funziona bene perche non so come CACCHIO mappare il /g.
+  # oare che in ruby ci sia solo /i x(xtended)  n(multiline)
+  def canonicalize
+    value = self
+    value = value.gsub( /^\s+/,  '')  # s/^\s+//;
+    value = value.gsub( /\s+$/,  '')  # value =~ s/\s+$//;
+    value = value.gsub( /\r*\n/n, ' ')  # value =~ s/\r*\n/ /g;
+    value = value.gsub( /\s+$/n , ' ')  # value =~ s/\s+$/ /g;
+    deb "Original:  '''#{self}'''"
+    deb "Canonical: '''#{value}'''"
+    return value
+  end
+  
+  # a manhouse :-(
+  def singolarizza
+    return self.singularize if self.respond_to?(:singularize)
+    deb("singularize '#{self}'")
+    m = self.match( /(.*)es$/)  # i.e. matches
+    return m[1] if (m)
+    m = self.match( /(.*)s$/)
+    return m[1] if m
+    return m
+  end
+
+=begin
+  greppa dalla prima occorrenza di FROM in poi
+
+=end
+  
+  def from_first_line_matching(regex_from)
+    arr_lines = self.split("\n")
+    ix1 = arr_lines.index_regex(regex_from) || 0
+    if ! ix1
+      throw "Cattivo Indice per arr_lines. Non greppa una fava con: #{regex_from}"
+      ix1 = 0
+    end
+    ix2 = arr_lines.length
+    deb "#{ix1}..#{ix2}"
+    joint = arr_lines[ix1..ix2].join("\n") #rescue ''
+    return joint 
+  end
+  
+  def to_first_line_matching(regex_from)
+    arr_lines = self.split("\n")
+    ix2 = arr_lines.index_regex(regex_from)
+    #ix2 = arr_lines.length
+    return arr_lines[0..ix2].join("\n")
+  end
+
+end #/Class String
+
+
+### Miscellaneous string functions
+
+def clear_screen
+  print "\e[2J\e[f"
+end
+alias :clear :clear_screen
+
+def title(s)
+  title_n(s)
+end
+def title_n(s,n=2)
+  "== #{s} =="
+end
+
+  
+
+LOREM_IPSUM = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin at purus id ante pulvinar dapibus. Donec risus justo, gravida ac vulputate a, lacinia eget leo. Duis quam tellus, tempus at feugiat a, eleifend et velit. Donec et enim id libero malesuada luctus nec at nibh. Sed elit est, interdum sit amet sollicitudin ac, vulputate eget metus. In hac habitasse platea dictumst. Cras vitae justo at turpis elementum sollicitudin. Etiam quis quam placerat erat tincidunt fermentum. Ut vel mauris magna. Vestibulum luctus leo eget lectus gravida ac dignissim enim vestibulum. Integer facilisis mi sed justo aliquet a lacinia lacus scelerisque.
+
+Aliquam sed purus vel felis euismod pharetra eu a ipsum. Suspendisse potenti. Mauris aliquet, lorem id mattis ornare, dolor mauris tincidunt tellus, ac feugiat urna sem eget diam. Nulla venenatis urna et elit lobortis eleifend. Ut feugiat adipiscing nisi vitae accumsan. Aliquam ullamcorper odio a nibh scelerisque non tincidunt urna ullamcorper. Sed vitae eleifend quam. Nunc vulputate vulputate viverra. Duis eu enim eros. Nunc lacinia nibh neque, sit amet varius arcu.
+
+Maecenas facilisis porttitor vestibulum. Phasellus nisl elit, porttitor id pulvinar nec, malesuada quis lectus. Suspendisse lacinia odio vitae eros molestie suscipit. Vivamus eu nulla ac augue adipiscing luctus. Curabitur rhoncus placerat dui a consectetur. Integer suscipit felis vitae eros mattis cursus. Integer sollicitudin ante in risus feugiat tincidunt sed sit amet libero. Nunc molestie lorem ut nulla aliquam viverra. Etiam bibendum mollis mattis. Phasellus ipsum tortor, egestas consequat sollicitudin non, hendrerit eu tortor. Nam at magna ipsum, non convallis ligula. Etiam ac eros a nunc elementum bibendum vitae vitae lacus. Vivamus placerat quam sit amet urna mattis in luctus nulla venenatis. Praesent tempus egestas interdum. Nulla facilisi. Nulla id ligula et nunc egestas dictum sed sodales tellus. Integer vestibulum commodo mauris, blandit porta lectus tincidunt quis. Vestibulum varius est eu turpis ultrices pellentesque.
+
+Donec aliquam elit quis augue tristique id lacinia augue laoreet. Duis placerat tellus eget urna vehicula volutpat. Vestibulum tortor dui, ultricies quis luctus sed, ultricies sit amet dui. Sed nec magna ac mauris imperdiet venenatis in id velit. Vestibulum non nibh nisi, eu elementum metus. Integer porttitor scelerisque pharetra. Maecenas eu tincidunt augue. Donec viverra diam lacinia ligula rhoncus viverra. Cras dictum rhoncus nisi sit amet malesuada. Quisque consectetur sollicitudin magna, nec faucibus nulla lacinia ac. Donec accumsan gravida odio, nec vehicula enim hendrerit sed. Etiam in mauris et mi sollicitudin congue non sit amet augue. Praesent nisi tortor, posuere vehicula rutrum interdum, tincidunt non tortor. Aliquam adipiscing mollis odio, eget accumsan lectus blandit sed. Sed tristique, ipsum eu laoreet dignissim, nunc nisi rhoncus tellus, sed molestie turpis ante vitae orci. Nullam tincidunt suscipit ligula sit amet sodales. Curabitur auctor tempus rutrum.
+
+Donec non venenatis lectus. Ut imperdiet felis quis augue viverra pellentesque. Duis sodales, magna at tincidunt volutpat, turpis tellus auctor lacus, et mollis ante odio in tellus. Aliquam euismod tempor aliquam. Vivamus at eros eget felis consequat faucibus dignissim consequat diam. Cras et dolor sagittis mi pharetra tincidunt vitae a tortor. Vestibulum at dictum augue. Sed commodo magna quis lectus bibendum accumsan. Aliquam consectetur feugiat augue, eget suscipit mi mattis ac. Donec at tristique lorem. Nulla non nisl sed felis volutpat ullamcorper." unless defined?(LOREM_IPSUM)
+
+def lorem_ipsum(len=0)
+  len == 0 ? 
+    LOREM_IPSUM :
+    LOREM_IPSUM[0..len]
+end
+
+alias :lorem :lorem_ipsum
+
+  # supports: strings, arrays and regexes :)
+  # @returns a Regexp
+def autoregex(anything)
+  deb "Autoregex() supercool! With a #{blue anything.class}"
+  case anything.class.to_s
+    when 'String' 
+      if anything.match(/^\/.*\/$/) # '/asd/' is probably an error! The regex builder trails with '/' automatically
+        fatal 23,"Attention, the regex is a string with trailing '/', are you really SURE this is what you want?!?"
+      end
+      return  Regexp.new(anything)
+    when 'Regexp'
+      return anything # already ok
+    when 'Array'
+      return Regexp.new(anything.join('|'))
+    else
+      #msg = "#{__FILE__}.#{__LINE__}: autoregex() Exception: Unknown class for autoregexing: #{red anything.class}"
+      msg = "Unknown class for autoregexing: #{red anything.class}"
+      $stderr.puts( msg )
+      raise( msg )
+  end
+  return nil
+end