epitools 0.5.133 → 0.5.136

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db1a5a887e1a937b76e39d061a8865503f7bfeb33f03094f5d7b8ce3749420e7
-  data.tar.gz: b5075843f8bd030de2e5313e9af3f53f97cae26fc0b52a609a06137fc015324c
+  metadata.gz: 4c080c53832ae049dd0ac7abedc41844d515b759fd081f4541855359a21eb75a
+  data.tar.gz: f6871df3e1da9c2cdb315ab49a5c76cea1eb6dfc8f776d6a3f44b3e6d59844fd
 SHA512:
-  metadata.gz: 0f13ae895b759edc3612970e335b743301bd102a4c73f619c16028acab0792a1d229d65ff40626d6c11334f95b020b055f9a18e6afc70a37ae74824b439c2f24
-  data.tar.gz: 8bac272ee77ee4bd4c493b2b6f6c394e1143bd57e73b77196f9798326e73749b1c940622e22ea792875718b59e7a01380d2766296df5c19a3a259a3f7e34fcd3
+  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.133
+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'
@@ -98,8 +98,11 @@ autoreq  :Mechanize,    'mechanize'
 autoreq  :HTTP,         'http'
 
 autoreq  :Nokogiri,     'nokogiri'
-autoreq  :Oga,          'oga'
 autoreq  :Ox,           'ox'
+autoreq  :Oga do
+  require 'oga'
+  require 'epitools/gem_ext/oga'
+end
 
 autoreq  :ANSI,         'ansi'
 

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}"] }
@@ -247,3 +254,13 @@ end
 def curl_json(url)
   JSON.parse(curl(url))
 end
+
+def cached_curl(url)
+  cache = "/tmp/curl-#{url.sha1}.cache"
+  if File.exist?(cache)
+    $stderr.puts "cached! => #{cache}"
+  else
+    File.write(cache, curl(url))
+  end
+  File.read(cache)
+end

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/gem_ext/oga.rb

@@ -0,0 +1,31 @@
+
+module Oga
+  module XML
+    # Serialize this node to HAML
+    module ElementToHAML
+      def to_haml
+        require 'html2haml'
+        require 'html2haml/html'
+        Html2haml::HTML.new(to_xml, {}).render.rstrip
+      end
+      alias_method :haml, :to_haml
+
+      def pretty
+        require 'coderay'
+        puts CodeRay.scan(haml, :haml).term
+      end
+      #alias_method :pp, :pretty
+    end
+
+    module PrettyNodeSet
+      def pretty
+        require 'coderay'
+        lesspipe(wrap: true) { |less| each { |node| less.puts CodeRay.scan(node.to_haml, :haml).term; less.puts; less.puts } }
+      end
+    end
+ 
+  end
+end
+
+Oga::XML::Element.include Oga::XML::ElementToHAML
+Oga::XML::NodeSet.include Oga::XML::PrettyNodeSet

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'
 ####################################################################