epitools 0.5.134 → 0.5.136

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2aefbc7936ad578ce3f2ae8806e67be1815f4e2a55ddf43a915bcdaa0ca9f68a
-  data.tar.gz: 6d09789e434d7cda9b66e25ecf1ebf9db61d6236f1342b83743330e42d9ab09f
+  metadata.gz: 4c080c53832ae049dd0ac7abedc41844d515b759fd081f4541855359a21eb75a
+  data.tar.gz: f6871df3e1da9c2cdb315ab49a5c76cea1eb6dfc8f776d6a3f44b3e6d59844fd
 SHA512:
-  metadata.gz: 4c98a36281937b7dd6e8f6154af595f5153d51803da0587eafc1a8dec26c96adac899e73c9ef49157b8fadcdf01fb845b60095d9ceb9722b5107c0eeaf6f8550
-  data.tar.gz: ccf09c13ef7df31e8d6994ba1c5550dc606fd61ac909c14f00c53788160a69cb53e7c425156a373732f4fbc7e021bde12c27e850be0ca1cf4735b86d9cf01285
+  metadata.gz: d93c4452eb2e0537265eb95497bf6a0ca9d9022f2ab099972a64904465eccabbe0d3f1901ff2b711940e4603bb6e7afd7c56f7b9b93eea4d9d7762f6453ed3ee
+  data.tar.gz: 75a2d4e10cf13071f4a2cab7239f6a2db7c3b0bb66a68ce603c75bbe5051c15d742308d9f370cc9fb045e6db2492942f8cd37a65db40ba235655e1ea4d429ac8

data/Rakefile

@@ -9,7 +9,7 @@ task :release => :build do
 end
 
 task :install => :build do
-  system "gem install --local epitools-#{gem_version}.gem"
+  system "gem install --user epitools-#{gem_version}.gem"
 end
 
 task :pry do
@@ -17,13 +17,11 @@ task :pry do
 end
 
 task :spec do
-  cmd = %w[rspec -fd -c spec]
+  cmd = %w[rspec --format documentation --force-color --pattern spec/*_spec.rb]
+  cmd.unshift "rescue" if system *%w[which rescue]
 
-  if system *%w[which rescue]
-    system *(["rescue"]+cmd)
-  else
-    system *cmd
-  end
+  p cmd
+  system *cmd
 end
 
 task :default => :spec

data/VERSION

@@ -1 +1 @@
-0.5.134
+0.5.136

data/lib/epitools/autoloads.rb

@@ -69,7 +69,7 @@ autoload :Path,            'epitools/path'
 autoload :Ezdb,            'epitools/ezdb'
 autoload :Browser,         'epitools/browser'
 autoload :Rash,            'epitools/rash'
-autoload :Ratio,           'epitools/ratio'
+autoload :Fraction,        'epitools/fraction'
 autoload :ProgressBar,     'epitools/progressbar'
 autoload :Trie,            'epitools/trie'
 autoload :MimeMagic,       'epitools/mimemagic'

data/lib/epitools/browser/cache.rb

@@ -37,7 +37,7 @@ class Browser
     end
 
 
-    def put(page, original_url=nil, options={})
+    def put(page, original_url=nil, **options)
       dmsg [:put, original_url]
 
       raise "Invalid page" unless valid_page?(page)

data/lib/epitools/browser.rb

@@ -36,7 +36,7 @@ class Browser
   #  :use_logs => false,               # Don't log the detailed transfer info
   #  :cookie_file => "cookies.txt"     # Save cookies to file
   #
-  def initialize(options={})
+  def initialize(**options)
     @last_get     = Time.at(0)
     @delay        = options[:delay]          || 1
     @delay_jitter = options[:delay_jitter]   || 0.2
@@ -85,7 +85,7 @@ class Browser
   end
 
   def load_cookies!
-    if File.exists? @cookie_file
+    if File.exist? @cookie_file
       agent.cookie_jar.load @cookie_file
       true
     else
@@ -126,7 +126,7 @@ class Browser
   # Options:
   #   :cached => true/false   | check cache before getting page
   #
-  def get(url, options={})
+  def get(url, **options)
 
     # TODO: Have a base-URL option
 
@@ -151,7 +151,7 @@ class Browser
       if use_cache and page = cache.get(url)
         puts "  |_ cached (#{page.content_type})"
       else
-        page = agent.get(url)
+        page = agent.get(url, [], options[:referer])
         @last_get = Time.now
         cache_put(page, url) if use_cache
       end

data/lib/epitools/clitools.rb

@@ -56,6 +56,13 @@ rescue Errno::EPIPE, Interrupt
 end
 
 
+#
+# Colorized puts (see: `String#colorize`)
+#
+def cputs(*args)
+  puts args.join("\n").colorize
+end
+
 #
 # Execute a `system()` command using SQL-style escaped arguments.
 #
@@ -179,11 +186,11 @@ end
 def geoip(addr, city_data='/usr/share/GeoIP/GeoIPCity.dat', country_data='/usr/share/GeoIP/GeoIP.dat')
   (
     $geoip ||= begin
-      if city_data and File.exists? city_data
+      if city_data and File.exist? city_data
         geo = GeoIP.new city_data
         proc { |addr| geo.city(addr) }
 
-      elsif country_data and File.exists? country_data
+      elsif country_data and File.exist? country_data
         geo = GeoIP.new country_data
         proc { |addr| geo.country(addr) }
 
@@ -202,7 +209,7 @@ def which(*bins)
   bins.flatten.each do |bin|
     ENV["PATH"].split(":").each do |dir|
       full_path = File.join(dir, bin)
-      return full_path if File.exists? full_path
+      return full_path if File.exist? full_path
     end
   end
   nil
@@ -234,7 +241,7 @@ def curl(url)
   curl_open(url).read
 end
 
-def curl_open(url, headers={})
+def curl_open(url, **headers)
   # headers["User-Agent"] ||= "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_5) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/85 Version/11.1.1 Safari/605.1.15"
   cmd = ["curl", "-LSs"]
   headers.each { |k,v| cmd += ["-H", "#{k}: #{v}"] }

data/lib/epitools/core_ext/array.rb

@@ -266,7 +266,7 @@ class Array
   #            5.0...9.0 => 5
   #          }
   #
-  def histogram(n_buckets=10, options={})
+  def histogram(n_buckets=10, **options)
 
     use_ranges = options[:ranges] || options[:hash]
 

data/lib/epitools/core_ext/numbers.rb

@@ -283,6 +283,16 @@ class Integer
   end
   alias_method :bits, :to_bits
 
+  #
+  # Convert this number to a Ruby-style string of platform-endian binary digits (eg: "0b011010101").
+  # Note: The `min_length` argument tells how long the string should be (padding the missing digits with 0's); defaults to 8.
+  #
+  def binary(min_length=8)
+    width = (log(2).ceil / min_length.to_f).ceil * min_length
+    "0b%0.#{width}b" % self
+  end
+  alias_method :bin, :binary
+
   #
   # Cached constants for encoding numbers into bases up to 64
   #
@@ -443,20 +453,40 @@ end
 class Float
 
   #
-  # Convert the float to a rounded percentage string (eg: "42%").
+  # Convert the float to a rounded percentage string (eg: "42.5%").
   # Its argument lets you specify how many decimals to display
   #
   # eg:
-  #    > 0.32786243.percent # => "33%"
+  #    > 0.32786243.percent # => "33.8%"
   #    > 0.32786243.percent(2) # => "32.79%"
   #
-  def percent(decimals=0)
+  def percent(decimals=1)
     "%0.#{decimals}f%%" % (self * 100)
   end
 
 end
 
 
+class Rational
+
+  #
+  # Convert the float to a rounded percentage string (eg: "42.5%")
+  # (see: Float#percent)
+  #
+  def percent(decimals=1)
+    to_f.percent(decimals)
+  end
+
+  #
+  # Alternate initializer (`Rational[1,2]`)
+  #
+  def self.[](*args)
+    Rational(*args)
+  end
+
+end
+
+
 class Prime
 
   #
@@ -485,3 +515,4 @@ end
 def primes
   Prime.instance
 end
+

data/lib/epitools/core_ext/object.rb

@@ -11,6 +11,9 @@ class Object
     Hash[ vars.zip(vals) ]
   end
 
+  def write_to(file)
+    open(file, "wb") { |f| f.write self.to_s }
+  end
 
   #
   # Gives you a copy of the object with its attributes changed to whatever was
@@ -36,7 +39,7 @@ class Object
   #
   # Good for chaining lots of operations together in a REPL.
   #
-  def with(options={})
+  def with(**options)
     if block_given?
       yield self
     else

data/lib/epitools/core_ext/string.rb

@@ -14,6 +14,13 @@ class String
   #
   STOP_WORDS = %w[a cannot into our thus about co is ours to above could it ourselves together across down its out too after during itself over toward afterwards each last own towards again eg latter per under against either latterly perhaps until all else least rather up almost elsewhere less same upon alone enough ltd seem us along etc many seemed very already even may seeming via also ever me seems was although every meanwhile several we always everyone might she well among everything more should were amongst everywhere moreover since what an except most so whatever and few mostly some when another first much somehow whence any for must someone whenever anyhow former my something where anyone formerly myself sometime whereafter anything from namely sometimes whereas anywhere further neither somewhere whereby are had never still wherein around has nevertheless such whereupon as have next than wherever at he no that whether be hence nobody the whither became her none their which because here noone them while become hereafter nor themselves who becomes hereby not then whoever becoming herein nothing thence whole been hereupon now there whom before hers nowhere thereafter whose beforehand herself of thereby why behind him off therefore will being himself often therein with below his on thereupon within beside how once these without besides however one they would between i only this yet beyond ie onto those you both if or though your but in other through yours by inc others throughout yourself can indeed otherwise thru yourselves]
 
+  #
+  # Are there any non-whitespace characters in the string?
+  #
+  def any?
+    not blank?
+  end
+
   #
   # Convert \r\n to \n
   #
@@ -28,6 +35,14 @@ class String
     Shellwords.escape(self)
   end
 
+  #
+  # Do what a browser would do when you type something into the address bar
+  #
+  def urlescape
+    @@uri_parser ||= URI::RFC2396_Parser.new
+    @@uri_parser.escape(self)
+  end
+
   #
   # Remove redundant whitespaces (not including newlines).
   #
@@ -115,7 +130,7 @@ class String
   alias_method :chomp_lines,   :each_chomped
 
 
-  def split_at(boundary, options={})
+  def split_at(boundary, **options)
     include_boundary = options[:include_boundary] || false
 
     boundary = Regexp.new(Regexp.escape(boundary)) if boundary.is_a?(String)
@@ -269,20 +284,39 @@ class String
     tr('n-za-mN-ZA-M', 'a-zA-Z')
   end
 
+  #
+  # Cache an `URI::RFC2396_Parser` instance, because it's slowwww to initialize
+  #
+  def _rfc2396_parser
+    @@rfc2396_parser ||= URI::RFC2396_Parser.new
+  end
+
   #
   # Convert non-URI characters into %XXes.
   #
   def urlencode
-    URI.escape(self)
+    #URI.escape(self)
+    _rfc2396_parser.escape(self)
   end
 
   #
   # Convert an URI's %XXes into regular characters.
   #
   def urldecode
-    URI.unescape(self)
+    _rfc2396_parser.unescape(self)
   end
 
+  #
+  #
+  #
+  def to_bigdecimal
+    BigDecimal
+    BigDecimal(self)
+  end
+  alias_method :to_d,       :to_bigdecimal
+  alias_method :to_dec,     :to_bigdecimal
+  alias_method :to_decimal, :to_bigdecimal
+
   #
   # URI.parse the string and return an URI object
   #
@@ -495,6 +529,68 @@ class String
     nums_and_units.map { |num, units| num.send(units) }.sum
   end
 
+
+  #
+  # Translate numbers with units (like 25k, 150GB, 15%, 5 hours) into their expanded numeric value
+  #
+  def parse_units
+    # extract the unit suffix
+    if self =~ /(\d[\d_]*(?:\.\d+)?)\s*([a-zA-Z]+\b|%(?= \s|$))/
+      units = $2.downcase
+      num   = $1 #.to_f
+      num   = num["."] ? num.to_f : num.to_i
+
+      case units
+      when "%"
+        # 0.01
+        num / 100.0
+      when "k"
+        # 10**3
+        num.thousand
+      when "m", "mm"
+        # 10**6
+        num.million
+      when "b", "bn"
+        # 10**9
+        num.billion
+      when "gib", "gb", "g"
+        num * 2**30
+      when "mib", "mb"
+        num * 2**20
+      when "kib", "kb"
+        num * 2**10
+      when "t", "tb"
+        # 10**12
+        num.trillion
+      when "q"
+        # 10**15
+        num.quadrillion
+      when "Q"
+        # 10**18
+        num.quintillion
+      when "min"
+        # 1.minute
+        num.minutes
+      when "hours", "h", "hr", "hrs"
+        # 1.hour
+        num.hours
+      when "d", "days", "dy"
+        num.days
+      else
+        raise "Invalid units: #{units.inspect}, in: #{self.inspect}"
+      end
+    else
+      raise "Couldn't find any units to parse! (expecting: '<a number><some letters>')"
+    end
+  end
+
+  alias_method :from_units,   :parse_units
+  alias_method :from_human,   :parse_units
+  alias_method :from_size,    :parse_units
+  alias_method :from_percent, :parse_units
+  alias_method :from_time,    :parse_units
+
+
   #
   # Print a hexdump of the string to STDOUT (coloured, if the terminal supports it)
   #

data/lib/epitools/fraction.rb

@@ -0,0 +1,131 @@
+#
+# A fraction! (Like a Rational, but ... uh ... in pure Ruby!)
+#
+# Can be compared, added, multiplied, simplified, "percent"ed, "to_f"ed, and printed/inspected.
+#
+class Fraction
+
+  attr_accessor :first, :last
+
+  alias_method :top, :first
+  alias_method :bottom, :last
+
+  alias_method :numerator, :first
+  alias_method :denominator, :last
+
+  #
+  # `first` is the top part of the fraction, `last` is the bottom (eg: `first/last`)
+  #
+  def initialize(first, last=1)
+    @first = first
+    @last = last
+  end
+
+  def self.[](*args)
+    new(*args)
+  end
+
+  include Comparable
+
+  def <=>(other)
+    to_f <=> other.to_f
+  end
+
+  #
+  # Returns a string representation: "a/b"
+  #
+  def to_s
+    "#{@first}/#{@last}"
+  end
+  alias_method :fraction, :to_s
+
+  #
+  # Returns the fraction as a float. (eg: Fraction[1,2].to_f == 0.5)
+  #
+  def to_f
+    if @last == 0
+      raise ZeroDivisionError
+    else
+      @first.to_f / @last
+    end
+  end
+
+  #
+  # Returns a string representing the number in percent
+  #
+  def percent
+    "%0.1f%%" % (to_f * 100)
+  end
+  alias_method :to_percent, :percent
+
+  #
+  # "#<Fraction: 1/2>"
+  #
+  def inspect
+    "#<Fraction: #{to_s}>"
+  end
+
+  #
+  # Adds together the tops and bottoms of the fractions.
+  #
+  # Example: For the fractions `a/c` and `b/d`, returns `a+b/c+d`
+  #
+  def +(r)
+    case r
+    when Integer
+      self + Fraction[r]
+    when Fraction
+      Fraction[ r.last*first + r.first*last, r.last*last ]
+    else
+      raise TypeError.new("Sorry, I can't add a Fraction and a #{r.class}. :(")
+    end
+  end
+
+  #
+  # Multiply the fractions
+  #
+  def *(v)
+    case v
+    when Integer
+      Fraction[ v*first, v*last ]
+    when Fraction
+      Fraction[ v.first*first, v.last*last ]
+    else
+      raise TypeError.new("I don't know how to multiply a Fraction and a #{v.class}. Sorry. :(")
+    end
+  end
+
+  def simplify
+    require 'prime'
+
+    # factor the numerator and denominator into hashes of { factor => exponent } pairs
+    n_fact, d_fact = [numerator, denominator].map { |n| Prime.prime_division(n).to_h }
+
+    # cancel out common factors by subtracting exponents
+    d_fact.each do |v, d_exp|
+      if n_exp = n_fact[v]
+        if n_exp < d_exp
+          d_fact[v] = d_exp - n_exp
+          n_fact[v] = 0
+        else
+          n_fact[v] = n_exp - d_exp # <= if n_exp == d_exp, this is 0, which covers the 3rd case
+          d_fact[v] = 0
+        end
+      end
+    end
+
+    # multiply the simplified factors back into full numbers
+    simp_n, simp_d = [n_fact, d_fact].map { |h| h.map{ |n, exp| n ** exp }.reduce(:*) }
+
+    Fraction[simp_n, simp_d]
+  end
+
+end
+
+#####################################################################################
+#
+# Fraction(a,b) is a wrapper for Fraction[a,b]
+#
+def Fraction(*args)
+  Fraction.new(*args)
+end

data/lib/epitools/hexdump.rb

@@ -26,7 +26,7 @@ module Hex
     :default => 7
   )
 
-  def self.dump(data, options={})
+  def self.dump(data, **options)
     base_offset   = options[:base_offset] || 0
     color         = options[:color].nil? ? true : options[:color]
     highlight     = options[:highlight]

data/lib/epitools/minimal.rb

@@ -253,7 +253,7 @@ module Kernel
   #
   # Global AwesomePrint method (which triggers the loading of AwesomePrint the first time it's called)
   #
-  def ap(object, options={})
+  def ap(object, **options)
     AwesomePrint
     Kernel.ap(object, options)
   end
@@ -275,13 +275,12 @@ end
 
 ####################################################################################
 #
-# Path("/some/path") is an alias for Path["/some/path"]
+# Path("/some/path") is a wrapper for Path["/some/path"]
 #
 def Path(arg)
   Path[arg]
 end
 
-
 ####################################################################
 require 'epitools/autoloads'
 ####################################################################

data/lib/epitools/path.rb

@@ -125,16 +125,17 @@ class Path
   # Initializers
   ###############################################################################
 
+  alias_class_method :old_new, :new
   def self.new(*args)
     if args.first =~ URI_RE and self != Path::URI
       Path::URI.new(args.first)
     else
-      super(*args)
+      old_new(*args)
     end
   end
 
-  def initialize(newpath, hints={})
-    send("path=", newpath, hints)
+  def initialize(newpath, **hints)
+    send("path=", newpath, **hints)
 
     # if hints[:unlink_when_garbage_collected]
     #   backup_path = path.dup
@@ -155,8 +156,8 @@ class Path
     Shellwords.escape(str)
   end
 
-  def self.glob(str, hints={})
-    Dir[str].map { |entry| new(entry, hints) }
+  def self.glob(str, **hints)
+    Dir[str].map { |entry| new(entry, **hints) }
   end
 
   def self.[](path)
@@ -194,7 +195,7 @@ class Path
   #
   # Note: The `hints` parameter contains options so `path=` doesn't have to touch the filesytem as much.
   #
-  def path=(newpath, hints={})
+  def path=(newpath, **hints)
     if hints[:type] or File.exist? newpath
       if hints[:type] == :dir or File.directory? newpath
         self.dir = newpath
@@ -816,7 +817,7 @@ class Path
   #    zopen("otherfile.gz", "w") #=> #<Zlib::GzipWriter:0x7fe30448>>
   #    zopen("test.txt.gz") { |f| f.read } # read the contents of the .gz file, then close the file handle automatically.
   #
-  def zopen(mode="rb", &block)
+  def zopen(mode="rb", **opts, &block)
     # if ext == "gz"
     #   io = open(mode)
     #   case mode
@@ -829,7 +830,7 @@ class Path
     #     raise "Unknown mode: #{mode.inspect}. zopen only supports 'r' and 'w'."
     #   end
     # elsif bin = COMPRESSORS[ext]
-    if bin = COMPRESSORS[ext]
+    if bin = (opts[:format] || COMPRESSORS[ext])
       if which(bin)
         case mode
         when "w", "wb"
@@ -868,18 +869,25 @@ class Path
 
   end
 
+  def self.zopen(filename, mode, &block)
+    Path.new(filename).zopen(mode, &block)
+  end
+
   ###############################################################################
   # Parsing files
   ###############################################################################
 
   #
   # Parse the file based on the file extension.
-  # (Handles json, html, yaml, xml, csv, marshal, and bson.)
+  # (Handles json, html, yaml, xml, csv, tsv, marshal, and bson.)
+  #
+  # The "format" option lets you specify the file format (eg: `Path["something.conf"].parse(format: "yaml")`)
+  # You can also pass CSV parsing options (eg: `Path["thing.csv"].parse(col_sep: "\t")`)
   #
-  def parse(io=self.io, forced_ext=nil, opts={})
-    case (forced_ext or ext.downcase)
+  def parse(io=self.io, **opts)
+    case (opts[:format] || ext.downcase)
     when 'gz', 'bz2', 'xz'
-      parse(zopen, exts[-2])
+      parse(zopen, format: exts[-2])
     when 'json'
       read_json(io)
     when 'html', 'htm'
@@ -889,7 +897,10 @@ class Path
     when 'xml', 'rdf', 'rss'
       read_xml(io)
     when 'csv'
-      read_csv(io, opts)
+      read_csv(io, **opts)
+    when 'tsv'
+      opts[:col_sep] ||= "\t"
+      read_csv(io, **opts)
     when 'marshal'
       read_marshal(io)
     when 'bson'
@@ -920,7 +931,8 @@ class Path
 
 
   def read_html(io=self.io)
-    Nokogiri::HTML(io)
+    #Nokogiri::HTML(io)
+    Oga.parse_html(io)
   end
   alias_method :from_html, :read_html
 
@@ -938,14 +950,15 @@ class Path
 
 
   # Parse the file as CSV
-  def read_csv(io=self.io, opts={})
+  def read_csv(io=self.io, **opts)
     CSV.new(io.read, **opts).each
   end
   alias_method :from_csv, :read_csv
 
   # Parse the file as XML
   def read_xml(io=self.io)
-    Nokogiri::XML(io)
+    # Nokogiri::XML(io)
+    Oga.parse_xml(io)
   end
 
   # Parse the file as a Ruby Marshal dump
@@ -1024,6 +1037,7 @@ class Path
     dest
   end
   alias_method :ren, :rename
+  alias_method :rename_to, :rename
 
   #
   # Works the same as "rename", but the destination can be on another disk.
@@ -1502,7 +1516,8 @@ class Path
   # TODO: Remove the tempfile when the Path object is garbage collected or freed.
   #
   def self.tmpfile(prefix="tmp")
-    path = Path.new(Tempfile.new(prefix).path, unlink_when_garbage_collected: true)
+    # path = Path.new(Tempfile.new(prefix).path, unlink_when_garbage_collected: true)
+    path = Path.new(Tempfile.new(prefix).path)
     yield path if block_given?
     path
   end
@@ -1633,7 +1648,7 @@ class Path::URI < Path
   # TODO: only include certain methods from Path (delegate style)
   #       (eg: remove commands that write)
 
-  def initialize(uri, hints={})
+  def initialize(uri, **hints)
     @uri = ::URI.parse(uri)
     self.path = @uri.path
   end

data/lib/epitools/pretty_backtrace.rb

@@ -67,7 +67,7 @@ end
 
 
 
-def color_backtrace_2(lines, options={})
+def color_backtrace_2(lines, **options)
 
   groups = lines.reverse.split_at { |line,nextline| line.path != nextline.path }
 

data/lib/epitools/rash.rb

@@ -11,7 +11,7 @@ class Rash
 
   attr_accessor :optimize_every
 
-  def initialize(initial={})
+  def initialize(initial)
     @hash           = {}
     @regexes        = []
     @ranges         = []

data/lib/epitools/term.rb

@@ -29,26 +29,62 @@ module Term
   # Return the [width,height] of the terminal.
   #
   def size
-    $stdout.winsize.reverse
+    $stdout.winsize.reverse rescue [80,25]
   end
 
   def width;  size[0]; end
   def height; size[1]; end
-  def goto(x,y); @x, @y = x, y; end
-  def pos; [@x, @y]; end
+  # def goto(x,y); @x, @y = x, y; end
+  # def pos; [@x, @y]; end
 
-  def clear
-    print "\e[H\e[J"
-  end
 
+  ##################################################################################
+  ### ANSI Stuff (see: ttps://en.wikipedia.org/wiki/ANSI_escape_code)
+  ##################################################################################
+
+  ##################################################################################
+  ## <n>K = Clear (part of) the line
+  ##################################################################################
+
+  # 2 = clear entire line
   def clear_line
     print "\e[2K"
   end
 
+  # 0 = clear to end of line
   def clear_eol
     print "\e[0K"
   end
 
+  ##################################################################################
+  ## <n>J = Clear (part of) the screen.
+  ##################################################################################
+
+  def clear
+    # If n is 2, clear entire screen (and moves cursor to upper left on DOS ANSI.SYS).
+    print "\e[2J\e[H"
+  end
+
+  def clear_all_above
+    # If n is 1, clear from cursor to beginning of the screen.
+    print "\e[1J"
+  end
+
+  def clear_all_below
+    # If n is 0 (or missing), clear from cursor to end of screen.
+    print "\e[0J"
+  end
+
+  def clear_scrollback_buffer!
+    # If n is 3, clear entire screen and delete all lines saved in the scrollback buffer (this feature was added for xterm and is supported by other terminal applications).
+    print "\e[3J"
+  end
+
+
+  ##################################################################################
+  ## <n>;<m>H = Move!
+  ##################################################################################
+
   def move_to(row: 1, col: 1)
     print "\e[#{row};#{col}H"
   end
@@ -82,11 +118,15 @@ module Term
     @back = back if back
   end
 
-  def puts(s)
-    # some curses shit
-  end
-
+  #
+  # curses-style scrollable terminal window
+  #
   class Window
+
+    # work in progress. probably requires an event loop and a higher order container for having multiple windows and a text-input and stuff.
+
+    attr_accessor :wrap
+
     def initialize
     end
 
@@ -94,21 +134,39 @@ module Term
     end
   end
 
+
   class Table
 
     # TODO:
     #
     # * make Table's configuration eaiser to remember by putting the formatting parameters in initialize
     #   eg: Table.new(elements, :sort=>:vertical).to_s
+    # * strip ansi
+    # * wrap contents
+    # * rounded corners
+    # * [far future] dynamic sortable filterable toggleable table
     #
 
     attr_accessor :border, :columns, :padding, :strip_color, :indent, :width, :height
 
-    def self.[](data)
-      self.new(data)
+    def self.print(thing, **opts)
+      raise "Can't tablize a #{thing.class}" unless thing.class < Enumerable
+      puts new(thing, **opts).display
+    end
+
+    def self.hprint(thing)
+      puts new(thing).in_rows
+    end
+
+    def self.vprint(thing)
+      puts new(thing).in_columns
+    end
+
+    def self.[](data, **opts)
+      new(data, **opts)
     end
 
-    def initialize(data, options={})
+    def initialize(data, **options)
       @data         = data.map(&:to_s)
       @strip_color = options[:ansi] || options[:colorized] || options[:colored] || options[:strip_color] || options[:strip_ansi]
 
@@ -185,7 +243,7 @@ module Term
     end
     alias_method :by_rows, :in_rows
 
-    def display #(opts={})
+    def display #(**opts)
       case @direction
       when :horizontal
         puts in_rows
@@ -198,7 +256,7 @@ module Term
       by_rows
     end
 
-    def render(rows, options={})
+    def render(rows, **options)
       num_cols  = rows.first.size
       result    = []
 

data/spec/core_ext_spec.rb

@@ -404,6 +404,15 @@ describe String do
     ]
   end
 
+  it "parses units" do
+    "50%".parse_units.should == 0.5
+    "1b".parse_units.should == 1.billion
+    "1gb".parse_units.should == 2**30
+
+    lambda { "whee".parse_units }.should raise_error
+    lambda { "57 butts".parse_units }.should raise_error
+  end
+
 end
 
 
@@ -491,15 +500,30 @@ describe Float do
     end
   end
 
-  it "percent" do
+  it "percents" do
     f = 0.716237
-    f.percent.should == "72%"
+    f.percent.should == "71.6%"
+    f.percent(0).should == "72%"
+    f.percent(1).should == "71.6%"
     f.percent(2).should == "71.62%"
     f.percent(3).should == "71.624%"
   end
 
 end
 
+describe Rational do
+
+  it "makes em" do
+    lambda { Rational[1,2] }.should_not raise_error
+  end
+
+  it "percents" do
+    Rational(1,2).percent.should == "50.0%"
+    Rational(1,3).percent(3).should == "33.333%"
+  end
+
+end
+
 describe Number do
 
   it "number?" do

data/spec/fraction_spec.rb

@@ -0,0 +1,53 @@
+require 'epitools/fraction'
+
+describe Fraction do
+
+#  before :each do
+#    @a = Fraction[1,1]
+#    @b = Fraction[1,2]
+#  end
+
+  it "adds normally" do
+    ( Fraction[1,1] + Fraction[1,2] ).should == Fraction[3,2]
+  end
+
+  it "doesn't let you add weird stuff together" do
+    -> { Fraction[1,2] + :splunge }.should raise_error(TypeError)
+  end
+
+  it "timeses normally" do
+    ( Fraction[1,1] * 2 ).should == Fraction[2,2]
+    ( Fraction[1,2] * 2 ).should == Fraction[2,4]
+    ( Fraction[1,1] * Fraction[1,2] ).should == Fraction[1,2]
+    ( Fraction[5,3] * Fraction[1,2] ).should == Fraction[5*1, 2*3]
+    ( Fraction[5,3] * Fraction[1,2] ).should == Fraction[5, 6]
+    ( Fraction[1,2] * Fraction[1,2] ).should == Fraction[1, 4]
+  end
+
+  it "doesn't let you times it with weird stuff" do
+    -> { Fraction[1,2] * ([:ayeeee]*100) }.should raise_error(TypeError)
+  end
+
+  it "floats" do
+    Fraction[1,1].to_f.should == 1.0
+    Fraction[1,2].to_f.should == 0.5
+
+    -> { Fraction[1,0].to_f }.should raise_error(ZeroDivisionError)
+  end
+
+  it "percents" do
+    Fraction[1,1].percent.should == "100.0%"
+    Fraction[1,2].percent.should == "50.0%"
+  end
+
+  it "simplifies" do
+    Fraction[2,4].simplify.should == Fraction[1,2]
+    Fraction[4,2].simplify.should == Fraction[2,1]
+  end
+
+  it "has a function-style wrapper! (for paren fans)" do
+    Fraction(1,2).should == Fraction[1,2]
+    Fraction(1,2).should == Fraction.new(1,2)
+  end
+
+end

data/spec/numwords_spec.rb

@@ -7,17 +7,14 @@ describe Numeric do
       10 => "ten",
       3_123 => "three thousand, one-hundred and twenty-three",
       123_124 => "one-hundred and twenty-three thousand, one-hundred and twenty-four",
-
       8_128_937_981_273_987_129_837_174_612_897_638_613 => "eight undecillion, one-hundred and twenty-eight decillion, nine-hundred and thirty-seven nonillion, nine-hundred and eighty-one octillion, two-hundred and seventy-three septillion, nine-hundred and eighty-seven sextillion, one-hundred and twenty-nine quintillion, eight-hundred and thirty-seven quadrillion, one-hundred and seventy-four trillion, six-hundred and twelve billion, eight-hundred and ninety-seven million, six-hundred and thirty-eight thousand, six-hundred and thirteen",
-
-      3_486_597_230_495_871_304_981_320_498_123_498_263_984_739_841_834_091_823_094_812_039_481_231_623_987_461_293_874_698_123_649_817_236 => "three duotrigintillion, four-hundred and eighty-six untrigintillion, five-hundred and ninety-seven trigintillion, two-hundred and thirty novemvigintillion, four-hundred and ninety-five octovigintillion, eight-hundred and seventy-one septenvigintillion, three-hundred and four sexvigintillion, nine-hundred and eighty-one quinvigintillion, three-hundred and twenty quattuorvigintillion, four-hundred and ninety-eight trevigintillion, one-hundred and twenty-three duovigintillion, four-hundred and ninety-eight unvigintillion, two-hundred and sixty-three vigintillion, nine-hundred and eighty-four novemdecillion, seven-hundred and thirty-nine octodecillion, eight-hundred and fourty-one septendecillion, eight-hundred and thirty-four sexdecillion, ninety-one quindecillion, eight-hundred and twenty-three quattuordecillion, ninety-four tredecillion, eight-hundred and twelve duodecillion, thirty-nine undecillion, four-hundred and eighty-one decillion, two-hundred and thirty-one nonillion, six-hundred and twenty-three octillion, nine-hundred and eighty-seven septillion, four-hundred and sixty-one sextillion, two-hundred and ninety-three quintillion, eight-hundred and seventy-four quadrillion, six-hundred and ninety-eight trillion, one-hundred and twenty-three billion, six-hundred and fourty-nine million, eight-hundred and seventeen thousand, two-hundred and thirty-six",
-
+      3_486_597_230_495_871_304_981_320_498_123_498_263_984_739_841_834_091_823_094_812_039_481_231_623_987_461_293_874_698_123_649_817_236 => "three duotrigintillion, four-hundred and eighty-six untrigintillion, five-hundred and ninety-seven trigintillion, two-hundred and thirty novemvigintillion, four-hundred and ninety-five octovigintillion, eight-hundred and seventy-one septenvigintillion, three-hundred and four sexvigintillion, nine-hundred and eighty-one quinvigintillion, three-hundred and twenty quattuorvigintillion, four-hundred and ninety-eight trevigintillion, one-hundred and twenty-three duovigintillion, four-hundred and ninety-eight unvigintillion, two-hundred and sixty-three vigintillion, nine-hundred and eighty-four novemdecillion, seven-hundred and thirty-nine octodecillion, eight-hundred and forty-one septendecillion, eight-hundred and thirty-four sexdecillion, ninety-one quindecillion, eight-hundred and twenty-three quattuordecillion, ninety-four tredecillion, eight-hundred and twelve duodecillion, thirty-nine undecillion, four-hundred and eighty-one decillion, two-hundred and thirty-one nonillion, six-hundred and twenty-three octillion, nine-hundred and eighty-seven septillion, four-hundred and sixty-one sextillion, two-hundred and ninety-three quintillion, eight-hundred and seventy-four quadrillion, six-hundred and ninety-eight trillion, one-hundred and twenty-three billion, six-hundred and forty-nine million, eight-hundred and seventeen thousand, two-hundred and thirty-six",
       1763241823498172490817349807213409238409123409128340981234781236487126348791263847961238794612839468917236489712364987162398746129834698172364987123 => "more than a googol! (148 digits)"
     }.each do |num, result|
       num.to_words.should == result
     end
 
-    lambda{ 1.523.million.billion.to_words }.should_not raise_error
+    lambda { 1.523.million.billion.to_words }.should_not raise_error
   end
 
   it "has .thousand, .million, etc." do

data/spec/path_spec.rb

@@ -147,7 +147,9 @@ describe Path do
     data = "<h1>The best webpage in the universe.</h1>"
     html = Path.tmpfile
     html.write data
-    html.read_html.at("h1").to_s.should == data
+
+    # html.read_html.at("h1").to_s.should == data
+    html.read_html.at_css("h1").to_s.should == data
 
   ensure
     yaml.rm
@@ -243,7 +245,7 @@ describe Path do
 
     old_name = path.to_s
 
-    dest = path.rename(:ext=>".dat")
+    dest = path.rename(path.with(ext: ".dat"))
 
     dest.to_s.should == old_name+".dat"
     path.to_s.should == old_name
@@ -253,10 +255,10 @@ describe Path do
     path.exists?.should == false
 
     path.touch
-    lambda { path.rename(:ext=>".dat") }.should raise_error(RuntimeError)
+    lambda { path.rename(path.with(ext: ".dat")) }.should raise_error(RuntimeError)
 
     dest.rm
-    path.rename!(:ext=>".dat")
+    path.rename!(path.with(ext: ".dat"))
     path.to_s.should_not == old_name
     path.exists?.should == true
 
@@ -413,6 +415,14 @@ describe Path do
 
     # system("gzip -c < #{tmpjson} > #{tmpjson}.gz")
 
+    # class method version
+    Path.zopen("#{tmpjson}.gz", "w") { |io| io.write(JSON.dump(hash)) }
+    tmpgzip = Path["#{tmpjson}.gz"]
+    tmpgzip.exists?.should == true
+    tmpgzip.size.should be > 0
+    tmpgzip&.rm
+
+    # instance method version
     tmpgzip = Path["#{tmpjson}.gz"]
     tmpgzip.zopen("w") { |io| io.write(JSON.dump(hash)) }
     tmpgzip.exists?.should == true

data/spec/sys_spec.rb

@@ -30,6 +30,11 @@ describe Sys::ProcessInfo do
       if p2 = p2s[p1.pid]
         matches += 1
         p1.command.should == p2.command
+
+        # FIXME: this behaves weirdly with kernel processes, eg:
+        # expected: "[kworker/u8:1-phy5]"
+        #      got: "[kworker/u8:1-events_unbound]" (using ==)
+
       end
     end
 

data/spec/zopen_spec.rb

@@ -1,49 +1,49 @@
-require 'epitools/zopen'
-require 'tempfile'
+# require 'epitools/zopen'
+# require 'tempfile'
 
-describe "zopen()" do
+# describe "zopen()" do
 
-  before :all do
-    @data = ("x"*100+"\n") * 1000
-    @tmp = Tempfile.new("zopen_spec")
+#   before :all do
+#     @data = ("x"*100+"\n") * 1000
+#     @tmp = Tempfile.new("zopen_spec")
 
-    @plainfile = @tmp.path
-    @gzfile    = "#{@tmp.path}.gz"
-  end
+#     @plainfile = @tmp.path
+#     @gzfile    = "#{@tmp.path}.gz"
+#   end
 
-  after :all do
-    File.unlink @plainfile
-    File.unlink @gzfile
-  end
+#   after :all do
+#     File.unlink @plainfile
+#     File.unlink @gzfile
+#   end
 
-  it "writes/reads a gz" do
-    f = zopen(@gzfile, "w")
-    f.write(@data).should == @data.size
-    f.close
+#   it "writes/reads a gz" do
+#     f = zopen(@gzfile, "w")
+#     f.write(@data).should == @data.size
+#     f.close
 
-    f = zopen(@gzfile, "r")
-    f.read.should == @data
-    f.close
-  end
+#     f = zopen(@gzfile, "r")
+#     f.read.should == @data
+#     f.close
+#   end
 
-  it "writes/reads non-gz files" do
-    zopen(@plainfile, "w") {|f| f.write(@data) }
+#   it "writes/reads non-gz files" do
+#     zopen(@plainfile, "w") {|f| f.write(@data) }
 
-    # readstyle
-    File.read(@plainfile).should == zopen(@plainfile).read
+#     # readstyle
+#     File.read(@plainfile).should == zopen(@plainfile).read
 
-    # blockstyle
-    open(@plainfile){|f| f.read }.should == zopen(@plainfile){|f| f.read }
-  end
+#     # blockstyle
+#     open(@plainfile){|f| f.read }.should == zopen(@plainfile){|f| f.read }
+#   end
 
-  it "is enumerable" do
-    zopen(@gzfile) do |f|
-      f.respond_to?(:each).should == true
-      f.respond_to?(:map).should == true
-      f.respond_to?(:inject).should == true
+#   it "is enumerable" do
+#     zopen(@gzfile) do |f|
+#       f.respond_to?(:each).should == true
+#       f.respond_to?(:map).should == true
+#       f.respond_to?(:inject).should == true
 
-      f.all?{|line| line =~ /^x+$/ }
-    end
-  end
+#       f.all?{|line| line =~ /^x+$/ }
+#     end
+#   end
 
-end
+# end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: epitools
 version: !ruby/object:Gem::Version
-  version: 0.5.134
+  version: 0.5.136
 platform: ruby
 authors:
 - epitron
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-31 00:00:00.000000000 Z
+date: 2023-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -69,6 +69,7 @@ files:
 - lib/epitools/core_ext/truthiness.rb
 - lib/epitools/core_ext/uri.rb
 - lib/epitools/daemonize.rb
+- lib/epitools/fraction.rb
 - lib/epitools/gem_ext/oga.rb
 - lib/epitools/hexdump.rb
 - lib/epitools/iter.rb
@@ -86,7 +87,6 @@ files:
 - lib/epitools/progressbar.rb
 - lib/epitools/rails.rb
 - lib/epitools/rash.rb
-- lib/epitools/ratio.rb
 - lib/epitools/semantic_version.rb
 - lib/epitools/slop.rb
 - lib/epitools/slop/LICENSE
@@ -105,14 +105,16 @@ files:
 - lib/epitools/wm.rb
 - spec/.rspec
 - spec/autoreq_spec.rb
-- spec/browser_spec.rb
 - spec/btree_spec.rb
 - spec/clitools_spec.rb
 - spec/colored_spec.rb
 - spec/core_ext_spec.rb
+- spec/fraction_spec.rb
 - spec/histogram_spec.rb
 - spec/iter_spec.rb
 - spec/lcs_spec.rb
+- spec/manual/browser_spec.rb
+- spec/manual/wm_spec.rb
 - spec/numwords_spec.rb
 - spec/path_spec.rb
 - spec/permutations_spec.rb
@@ -122,7 +124,6 @@ files:
 - spec/sys_spec.rb
 - spec/term_spec.rb
 - spec/typed_struct_spec.rb
-- spec/wm_spec.rb
 - spec/zopen_spec.rb
 homepage: http://github.com/epitron/epitools
 licenses:
@@ -143,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.21
+rubygems_version: 3.3.25
 signing_key:
 specification_version: 3
 summary: Not utils... METILS!

data/lib/epitools/ratio.rb

@@ -1,78 +0,0 @@
-#
-# The ratio between two numbers (eg: 2:1, 3:4)
-#
-# Can be compared, added, "percent"ed, "to_f"ed, and displayed.
-#
-class Ratio
-
-  include Comparable
-
-  def <=>(other)
-    to_f <=> other.to_f
-  end
-
-  attr_accessor :first, :last
-
-  def self.[](*args)
-    new(*args)
-  end
-
-  #
-  # `first` is the top part of the ratio, `last` is the bottom (eg: `first/last`)
-  #
-  def initialize(first, last=1)
-    @first = first
-    @last = last
-  end
-
-  #
-  # Returns a string representation: "a/b"
-  #
-  def to_s
-    "#{@first}/#{@last}"
-  end
-  alias_method :ratio, :to_s
-
-  #
-  # Returns the ratio as a float. (eg: Ratio[1,2].to_f == 0.5)
-  #
-  def to_f
-    if @last == 0
-      0.0
-    else
-      @first.to_f / @last
-    end
-  end
-
-  #
-  # Returns a string representing the number in percent
-  #
-  def percent
-    "%0.1f%%" % (to_f * 100)
-  end
-  alias_method :to_percent, :percent
-
-  #
-  # "#<Ratio: 1/2>"
-  #
-  def inspect
-    "#<Ratio: #{to_s}>"
-  end
-
-  #
-  # Adds together the tops and bottoms of the ratios.
-  #
-  # Example: For the ratios `a/c` and `b/d`, returns `a+b/c+d`
-  #
-  def +(other)
-    Ratio.new( first+other.first, last+other.last)
-  end
-
-end
-
-#
-# Function-style wrapper
-#
-def Ratio(*args)
-  Ratio.new(*args)
-end