epitools 0.5.91 → 0.5.92

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6c6d7b162f65bd756eda3337887088cf8b95d2b8
-  data.tar.gz: cf4e36eac8eca4fbc4b12c05e45df8f1ebc4785c
+  metadata.gz: e5af87dba30589c9d2cf9367cc81758b72b2a853
+  data.tar.gz: d100d1a465f5d5088176a7d9d624e9460e7774b8
 SHA512:
-  metadata.gz: 7ff66deb700f7546b0437090a7dcb014861c5035aff6e006536548ca78478e2e0a2822877324edf021cf919eec3d6f5f9249baad45b17cd3ae4bfad7b23e84d5
-  data.tar.gz: 396555164bb482c1d3c3a61cf87217baa2504a61f63c1c62d39f4bcc362228dd0868257e9a1a4956eef97a6e3ff6507617c18ff14de0bad992708f6da91ca396
+  metadata.gz: fe5397193aed765f41464fe9fad1da4cb98d5a8c47b6c7aa5d5a7e8da0235aa21a2190839e929f2d13692594e8d39147366388f9fd7f72eddd4d9232b9e238e5
+  data.tar.gz: 6c85fda4344ecbecf77539a32e76660585ebf6222f955f3b1deb156a42922430a2bd137c5ffafc489285a7fd9d714e2cec89d06a03d7d09940a3c1a56cbadd1b

data/Snakefile

@@ -0,0 +1 @@
+🐍

data/VERSION

@@ -1 +1 @@
-0.5.91
+0.5.92

data/lib/epitools/core_ext/enumerable.rb

@@ -405,6 +405,20 @@ module Enumerable
   end
   alias_method :grouped, :groups
 
+  #
+  # Sort strings by their numerical values
+  #
+  def sort_numerically
+    sort_by do |e|
+      case e
+      when String
+        e.split(/(\d+)/).map { |s| s =~ /^\d+$/ ? s.to_i : s }
+      else
+        [e]
+      end
+    end
+  end
+
   #
   # Multiplies this Enumerable by something. (Same behaviour as Enumerator#*)
   #

data/lib/epitools/minimal.rb

@@ -256,6 +256,36 @@ end
 
 ####################################################################
 
+class << ARGV
+  def paths_R
+    the_expander = proc do |paths|
+      paths.map { |path| path.dir? ? the_expander.(path.ls_R) : path }
+    end
+
+    the_expander.(paths)
+  end
+  alias_method :recursive_paths, :paths_R
+
+  def paths
+    map(&:to_Path)
+  end
+
+  def opts
+    partition { |arg| arg[/^--?\w{1,2}/].nil? }
+  end
+
+  def args
+    self - opts
+  end
+
+  def regexes
+    map { |arg| /#{Regexp.escape arg}/i }
+  end
+
+end
+
+####################################################################
+
 require 'epitools/autoloads'
 
 ####################################################################

data/spec/core_ext_spec.rb

@@ -5,32 +5,32 @@ describe Object do
 
   it "withs" do
     class Cookie; attr_accessor :size, :chips; end
-    
+
     c = Cookie.new; c.size = 10; c.chips = 200
     w = c.with(:chips=>50)
-    
+
     w.size.should      == c.size
     w.chips.should_not == c.chips
     w.should_not       === c
   end
-  
+
   it "in?" do
     5.in?([1,2,3,4,5,6]).should   == true
     5.in?(1..10).should           == true
     5.in?(20..30).should          == false
     "butt".in?("butts!!!").should == true
   end
- 
+
   it "times" do
-    lambda { 
+    lambda {
       time("time test") { x = 10 }
     }.should_not raise_error
 
-    lambda { 
+    lambda {
       time("time test") { raise "ERROR" }
     }.should raise_error
   end
-  
+
   it "benches" do
     lambda { bench { rand }                 }.should_not raise_error
     lambda { bench(20) { rand }             }.should_not raise_error
@@ -43,59 +43,59 @@ describe Object do
     s = Struct.new(:a,:b).new
     s.a = 5
     s.b = 10
-    
-    s.try(:a).should == 5 
+
+    s.try(:a).should == 5
     s.try(:b).should == 10
     s.try(:c).should == nil
-    
+
     lambda { s.try(:c) }.should_not raise_error
     lambda { s.c }.should raise_error
 
     def s.test(a); a; end
-    
+
     s.test(1).should                == 1
     s.try(:test, 1).should          == 1
-    
+
     lambda { s.test }.should raise_error
     lambda { s.try(:test) }.should raise_error
-    
+
     def s.blocky; yield; end
-    
+
     s.blocky{ 1 }.should            == 1
     s.try(:blocky){ 1 }.should      == 1
     s.try(:nonexistant){ 1 }.should == nil
   end
-  
+
   it "nots" do
     10.even?.should == true
     10.not.even?.should == false
   end
-  
+
   it "alias_class_methods" do
     class Blah
       def self.classmethod
         true
       end
-      
+
       alias_class_method :aliased, :classmethod
     end
-    
-    lambda do 
+
+    lambda do
       Blah.classmethod.should == true
     end.should_not raise_error
-    
+
   end
 
   it "marshals/unmarshals" do
     :whee.marshal.unmarshal.should == :whee
     :whee.marshal.should == Marshal.dump(:whee)
   end
-    
+
   it "selfs" do
     a = [1,2,3,4]
     a.map(&:self).should == a
   end
-  
+
   it "memoizes" do
 
     class Fake
@@ -118,32 +118,32 @@ describe Object do
     f.instance_variable_get("@temp").should == true
     f.instance_variable_get("@cacheme").should == true
   end
-  
+
 end
 
 
 describe Class do
-  
+
   it "uses" do
     module Test1
       def test1; :test1; end
     end
-    
+
     module Test2
       def test2; :test2; end
     end
-    
+
     Hash.using(Test1).new.test1.should == :test1
     Hash.using(Test2).new.test2.should == :test2
     h = Hash.using(Test1, Test2).new
     h.test1.should == :test1
     h.test2.should == :test2
-    
+
     Hash.using(Test1) do |h|
       h.new.test1.should == :test1
-    end    
+    end
   end
-  
+
 end
 
 
@@ -159,19 +159,19 @@ describe Numeric do
     BigDecimal.new("1111.1234567").commatize.should == "1,111.1234567"
     -1234567.1234567.underscorize.should == "-1_234_567.1234567"
   end
-  
+
   it "does time things" do
     1.second.should             == 1
     1.minute.should             == 60
     2.minutes.should            == 120
     2.hours.should              == 120*60
     2.5.days.should             == 3600*24*2.5
-    
+
     5.days.ago.to_i.should      == (Time.now - 5.days).to_i
-    1.year.ago.year.should      == Time.now.year - 1 
+    1.year.ago.year.should      == Time.now.year - 1
     5.days.from_now.to_i.should == (Time.now + 5.days).to_i
   end
-  
+
   it "thingses" do
     10.things.should             == [0,1,2,3,4,5,6,7,8,9]
     4.things {|n| n * 5 }.should == [0,5,10,15]
@@ -197,13 +197,13 @@ describe Numeric do
 end
 
 describe String do
-  
+
   it "anys?" do
     "".should_not be_any
     "\n".should_not be_any
     "YAY".should be_any
   end
-  
+
 
 
   it "rot13s" do
@@ -211,24 +211,24 @@ describe String do
     message.rot13.should_not   == message
     message.rot13.rot13.should == message
   end
-  
+
   it "tightens" do
     " hi   there".tighten.should == "hi there"
   end
-  
+
   it "dewhitespaces" do
     "\nso there   i \n was, eating my cookies".dewhitespace.should == "so there i was, eating my cookies"
   end
-  
+
   it "nice_lineses" do
-    "\n\n\nblah\n\n\nblah\n\n\n".nice_lines.should == ["blah", "blah"]    
+    "\n\n\nblah\n\n\nblah\n\n\n".nice_lines.should == ["blah", "blah"]
   end
 
   it "nice_htmls" do
     s = "<a><b><p><c>whee</a>"
     s.nice_html.should_not == s
   end
-  
+
   it "wraps" do
     s1 = "Hello there, I am a sentence or series of words."
     s2 = "012345678901234567890123456789012345678901234567"
@@ -265,27 +265,27 @@ describe String do
   it "strips color" do
     s = "woot!"
     color_s = s.light_green
-    color_s.strip_color.should == s  
+    color_s.strip_color.should == s
   end
-  
+
   it "urlencodes/decodes" do
     s = "hi + there & mom + !!!!! I AM ON RSPEC"
     s.urlencode.should_not == s
     s.urlencode.should == "hi%20+%20there%20&%20mom%20+%20!!!!!%20I%20AM%20ON%20RSPEC"
     s.urlencode.urldecode.should == s
   end
-  
+
   it "to_paramses" do
     "file=yay&setting=1&awesome=true".to_params.should == {"file" => "yay", "setting"=>"1", "awesome"=>"true"}
   end
-  
+
   it "md5/sha1s" do
     s = "hashme"
     s.md5.should_not == s
     s.sha1.should_not == s
     s.sha1.should_not == s.md5
   end
-  
+
   it "gzips/gunzips/delfates/inflates" do
     s = "asdklfjasdfjaeh"
     s.deflate.should_not == s
@@ -293,14 +293,14 @@ describe String do
 
     s.gzip.should_not == s
     s.gzip.gunzip.should == s
-    
+
     s.gzip(9).size.should < s.gzip(0).size
     s.deflate(9).size.should < s.deflate(0).size
   end
 
   it "starts/endswith" do
-    "blahblahblah".startswith("blah").should == true    
-    "blahblahblah".endswith("blah").should == true    
+    "blahblahblah".startswith("blah").should == true
+    "blahblahblah".endswith("blah").should == true
   end
 
   it "amounts" do
@@ -320,7 +320,7 @@ describe String do
   it "n choose r" do
     n = 49
     r = 6
-    
+
     n.choose(r).should == n.fact / (r.fact * (n-r).fact)
   end
 
@@ -340,39 +340,39 @@ end
 
 
 describe Integer do
-  
+
   it "integer?s" do
-    
+
     {
       true  => [ "123", "000", 123 ],
       false => [ "123asdf", "asdfasdf", Object.new, nil, 123.45 ]
     }.each do |expected_result, objects|
       objects.each { |object| object.integer?.should == expected_result }
     end
-    
+
   end
-  
+
   it "has bits" do
     1.to_bits.should == [1]
     2.to_bits.should == [0,1]
     3.to_bits.should == [1,1]
     42.to_bits.should == [0,1,0,1,0,1]
-    
+
     # round trip
     20.times do
       n = rand(918282393982)
       n.to_bits.reverse.join.to_i(2).should == n
     end
   end
-  
+
   it "slices into bits" do
-    i = "111011".to_i(2) 
-    # Note: to_i(2) accepts big-endian, while the Fixnum#[] slicing will return little endian. 
+    i = "111011".to_i(2)
+    # Note: to_i(2) accepts big-endian, while the Fixnum#[] slicing will return little endian.
     #       So make sure to reverse the bit string for the specs.
 
     i[0].should == 1
     i[2].should == 0
-    
+
     i[0..2].should == [1,1,0]
     i[-3..-1].should == [1,1,1]
     i[0..-1].should == [1,1,0,1,1,1]
@@ -380,20 +380,20 @@ describe Integer do
 
   it "converts to/from base62" do
     Integer::BASE62_BASE.should == 62
-  
+
     [1,20,500,501,34191923].each do |n|
       n.to_base62.from_base62.should == n
     end
-    
+
     sum = "asdf".md5
     sum.to_base62.from_base62.to_s(16).should == sum
   end
-  
+
   it "factors numbers" do
     10.factors.should == [2,5]
     256.factors.should == [2,2,2,2,2,2,2,2]
   end
-  
+
   it "primes numbers" do
     [3,5,7,11,13,17,23,3628273133].all? { |n| n.should be_prime }
   end
@@ -443,24 +443,24 @@ describe Number do
 end
 
 describe Array do
-  
+
   it "squashes" do
     [1,2,[3,4,[5],[],[nil,nil],[6]]].squash.should == [1,2,3,4,5,6]
   end
-  
+
   it "remove_ifs" do
     nums = [1,2,3,4,5,6,7,8,9,10,11,12]
     even = nums.remove_if { |n| n.even? }   # remove all even numbers from the "nums" array and return them
-    odd = nums         
-    
+    odd = nums
+
     even.should == [2,4,6,8,10,12]
     odd.should == [1,3,5,7,9,11]
   end
-  
+
   it "rzips" do
     [5,39].rzip([:hours, :mins, :secs]).to_a.should == [ [5, :mins], [39, :secs] ]
   end
-  
+
   it "middles" do
     a = [0,1,2,3,4,5]
     a.middle.should == 2
@@ -477,7 +477,7 @@ describe Array do
     a.mode.should == 5
     a.mean.should == a.sum.to_f / a.size
   end
-  
+
   it "/'s" do
     a = [1,2,3,4,5]
     b = [1,2,3,4]
@@ -485,15 +485,15 @@ describe Array do
     # splits?
     (a/2).should == [[1,2,3],[4,5]]
     (a/3).should == [[1,2],[3,4],[5]]
-    
-    (b/2).should == [[1,2],[3,4]] 
+
+    (b/2).should == [[1,2],[3,4]]
   end
-  
+
   it "includes?s" do
     [:a, :b, :c].includes?(:c).should == true
     [:a, :b, :c].includes?(5).should == false
   end
-  
+
 end
 
 
@@ -501,17 +501,17 @@ describe Enumerable do
 
   it "maps deeply" do
     [["a\n", "b\n"], ["c\n", "d\n"]].map_recursively(&:strip).should == [ %w[a b], %w[c d] ]
-    
-    [[1,2],[3,4]].map_recursively {|e| e ** 2}.should == [[1,4],[9,16]] 
-    [1,2,3,4].map_recursively {|e| e ** 2}.should == [1,4,9,16] 
-    [[],[],1,2,3,4].map_recursively {|e| e ** 2}.should == [[], [], 1, 4, 9, 16] 
+
+    [[1,2],[3,4]].map_recursively {|e| e ** 2}.should == [[1,4],[9,16]]
+    [1,2,3,4].map_recursively {|e| e ** 2}.should == [1,4,9,16]
+    [[],[],1,2,3,4].map_recursively {|e| e ** 2}.should == [[], [], 1, 4, 9, 16]
   end
-  
+
   it "selects deeply" do
     [[1,2],[3,4]].select_recursively {|e| e % 2 == 0 }.should == [[2],[4]]
-    [{},"Blah",1,2,3,4].select_recursively {|e| e == 2 }.should == [2] 
+    [{},"Blah",1,2,3,4].select_recursively {|e| e == 2 }.should == [2]
   end
-  
+
   it "splits" do
     [1,2,3,4,5].split_at     {|e| e == 3}.should == [ [1,2], [4,5] ]
     [1,2,3,4,5].split_after  {|e| e == 3}.should == [ [1,2,3], [4,5] ]
@@ -527,21 +527,21 @@ describe Enumerable do
   it "splits with nested things" do
     array = [ [],["a"],"a",[1,2,3] ]
 
-    lambda { 
+    lambda {
       array.split_at("a")
     }.should_not raise_error
-    
-    array.split_at("a").should     == [ array[0..1], array[3..3] ] 
+
+    array.split_at("a").should     == [ array[0..1], array[3..3] ]
     array.split_at([1,2,3]).should == [ array[0..2] ]
   end
-  
+
   it "splits with arbitrary objects" do
     arbitrary = Struct.new(:a, :b, :c)
-    
+
     particular = arbitrary.new(1,2,3)
     array = [ arbitrary.new, arbitrary.new, particular, arbitrary.new]
-    
-    array.split_at(particular).should == [ array[0..1], array[3..3] ]    
+
+    array.split_at(particular).should == [ array[0..1], array[3..3] ]
   end
 
   it "splits lazily" do
@@ -566,7 +566,7 @@ describe Enumerable do
       result.to_a.should == chunks
     end
   end
-  
+
   it "sums" do
     [1,2,3,4,5].sum.should == 15
     [1,2,3,4,5].sum { 1 }.should == 5
@@ -586,29 +586,29 @@ describe Enumerable do
     a.foldl(:+).should == a.sum
     %w[hi there].foldl(:+).should == "hithere"
 
-    [ [1],[2],[3],[4] ].foldl(:+).should == [1,2,3,4] 
+    [ [1],[2],[3],[4] ].foldl(:+).should == [1,2,3,4]
   end
-  
+
   it "powersets" do
-    [1,2,3].powerset.should == [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]
-    [1,2].to_enum.powerset.should == [[], [1], [2], [1, 2]]
+    [1,2,3].powerset.to_a.should == [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]
+    [1,2].to_enum.powerset.to_a.should == [[], [1], [2], [1, 2]]
   end
-  
+
   it "unzips" do
     [ [:a, 1], [:b, 2] ].unzip.should == [ [:a, :b], [1, 2] ]
   end
-  
+
   it "group_neighbours_bys" do
     a = [1,2,5,6,7,10,11,13]
     result = a.group_neighbours_by { |a,b| b-a <= 1 }
     result.should == [[1,2],[5,6,7],[10,11],[13]]
   end
-  
+
   it "includes?s" do
     [:a, :b, :c].to_enum.includes?(:c).should == true
     [:a, :b, :c].to_enum.includes?(5).should == false
   end
-  
+
   it "permutatitons and combinations" do
     10.times.permutation(2).to_a.should == 10.times.to_a.permutation(2).to_a
     10.times.combination(2).to_a.should == 10.times.to_a.combination(2).to_a
@@ -625,12 +625,18 @@ describe Enumerable do
     (a * b).to_a.should == [[1,3],[1,4],[2,3],[2,4]]
   end
 
+  it "sorts strings numerically" do
+    a  = ["a1", "a11", "a2", "a3"]
+    a.sort_numerically.should == ["a1", "a2", "a3", "a11"]
+    a.sort.should_not == a.sort_numerically
+  end
+
 end
 
 describe Enumerator do
 
   it "spins" do
-    lambda { 
+    lambda {
       (1..20).each.with_spinner(1).each { }
     }.should_not raise_error
   end
@@ -644,7 +650,7 @@ describe Enumerator do
   end
 
   it "multiplies" do
-    e = [1,2,3].to_enum * 3 
+    e = [1,2,3].to_enum * 3
     e.to_a.should == [1,2,3]*3
 
     e = [1,2].to_enum * [3,4].to_enum
@@ -681,18 +687,18 @@ describe Hash do
 
   it "selects recursively" do
     # nevermind. hashes are stupid.
-    # {1=>2, 3=>{4=>5, 6=>7}}.select_recursively {|k,v| k == 1 }.should == {1=>2} 
+    # {1=>2, 3=>{4=>5, 6=>7}}.select_recursively {|k,v| k == 1 }.should == {1=>2}
   end
-    
+
   it "maps keys" do
     h = @h.map_keys{|k| k.upcase}
     h.keys.should   == @h.keys.map{|k| k.upcase}
     h.values.should == @h.values
-    
+
     h.map_keys! { 1 }
     h.keys.should   == [1]
   end
-  
+
   it "maps values" do
     h = @h.map_values{|v| v.upcase}
 
@@ -713,24 +719,24 @@ describe Hash do
 
     h.slice("nonexistant").should == {}
   end
-  
+
   it "mkdir_p's and trees" do
     h = {}
     h.mkdir_p(["a", "b", "c"]).should    == {"a"=>{"b"=>{"c"=>{}}}}
     h.mkdir_p(["a", "b", "whoa"]).should == {"a"=>{"b"=>{"c"=>{}, "whoa"=>{}}}}
-    
-    lambda { 
+
+    lambda {
       h.tree.should =~ ["a", "  b", "    c", "    whoa"]
     }.should_not raise_error
   end
-  
+
   it "to_querys" do
     # this will probably fail half the time in Ruby 1.8 because the hash order is random
     params = {"donkeys"=>"7", "stubborn"=>"true"}
     params.to_query.to_params.should == params
     params.to_query.in?(["donkeys=7&stubborn=true", "stubborn=true&donkeys=7"]).should == true
   end
-  
+
   it "includes?s and key?s" do
     @h.key?("key1").should      == true
     @h.includes?("key1").should == true
@@ -743,11 +749,11 @@ describe Hash do
     changes = a.diff(b)
     changes.should == {:a=>{:c=>[1, 2]}, :b=>[2, nil]}
     a.apply_diff(changes).should == b
-    
+
     a.apply_diff!(changes)
     a.should == b
   end
-  
+
 end
 
 
@@ -761,7 +767,7 @@ describe Time do
     2.months.ago.in_words.should       == "2 months ago"
     2.years.ago.in_words.should        == "2 years ago"
     2.5.years.ago.in_words.should      == "2 years ago"
-    
+
     2.5.years.from_now.in_words.should == "2 years from now"
   end
 end
@@ -770,14 +776,14 @@ end
 describe Binding do
   a = 1
   b = proc { a }
-  
+
   b.binding.keys.should =~ [:a, :b]
   b.binding.keys.should == b.binding.local_variables
-  
+
   b.binding[:a].should  == 1
   b.binding["a"].should == 1
   b.binding[:b].should  == b
-  
+
   b.binding[:a] = 5
   b.binding[:a].should  == 5
   b.call.should         == 5
@@ -792,23 +798,23 @@ describe Proc do
     a &= proc { 3 }
     a.call.should == [[1,2],3]
   end
-  
+
   it "chains procs" do
     b = proc { 1 } | proc { |input| input + 1 }
     b.call.should == 2
     b = b.chain( proc { |input| input + 1 } )
-    b.call(1).should == 3 
+    b.call(1).should == 3
   end
-    
+
 end
 
 
 describe BasicObject do
-  
+
   it "is blank!" do
     BasicObject.methods(false).should == []
   end
-  
+
 end
 
 
@@ -874,18 +880,18 @@ end
 
 
 describe "truthiness" do
-  
+
   it "is truthy!" do
     {
       # truthy things
       true => [
         "yes", "on", "1", "Enabled",
-        1, 1.7, 
+        1, 1.7,
         :blah, true,
         [1,2,3], [1,2,3].to_enum,
         1938389127239847129803741980237498012374,
       ],
-      
+
       # untruthy things
       false => [
         "", " ", "\t\n ", "asdf", 0, 0.0, false, nil, [], [].to_enum,
@@ -894,7 +900,7 @@ describe "truthiness" do
       objs.each { |obj| obj.truthy?.should == truthiness }
     end
   end
-  
+
 end
 
 
@@ -903,11 +909,11 @@ describe "proper grammar" do
   it "responds_to?" do
     proc{}.responds_to?(:call).should == true
   end
-  
+
   it "includes?" do
     [1,2,3,4,5].includes?(5).should == true
   end
-  
+
   it "is_an?" do
     Object.new.is_an?(Object).should == true
   end
@@ -930,11 +936,11 @@ describe "global methods" do
 
   it "locals's" do
     require 'binding_of_caller'
-  
+
     a = 5
     b = 10
     _what_ = :splunge
-    
+
     locals.should == {:a=>5, :b=>10}
   end
 
@@ -943,10 +949,10 @@ end
 
 describe "to_jsons and to_yamls" do
   data = {"a"=>"b", "yes"=>true, "hello"=>[1,2,3,4,5]}
-  data.to_json.from_json.should == data  
+  data.to_json.from_json.should == data
 
   data = {:a=>"b", 1=>true, "hello"=>[1,2,3,4,5]}
-  data.to_yaml.from_yaml.should == data  
+  data.to_yaml.from_yaml.should == data
 end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: epitools
 version: !ruby/object:Gem::Version
-  version: 0.5.91
+  version: 0.5.92
 platform: ruby
 authors:
 - epitron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-20 00:00:00.000000000 Z
+date: 2016-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -40,6 +40,7 @@ files:
 - LICENSE
 - README.rdoc
 - Rakefile
+- Snakefile
 - TODO
 - VERSION
 - lib/epitools.rb
@@ -123,9 +124,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 3
 summary: Not utils... METILS!
 test_files: []
-has_rdoc: