epitools 0.5.1 → 0.5.2

data/lib/epitools/rash.rb

@@ -14,6 +14,7 @@ class Rash
   def initialize(initial={})
     @hash           = {}
     @regexes        = []
+    @ranges         = []
     @regex_counts   = Hash.new(0)
     @optimize_every = 500
     @lookups        = 0
@@ -21,59 +22,70 @@ class Rash
     update(initial)
   end
 
+  def update(other)
+    for key, value in other
+      self[key] = value
+    end
+    self
+  end
+  
   def []=(key, value)
-    if key.is_a? Regexp
+    case key
+    when Regexp
       #key = normalize_regex(key)  # this used to just do: /#{regexp}/
       @regexes << key
+    when Range
+      @ranges << key
     end
     @hash[key] = value
   end
   
-  def search_regexes(string)
-    @regexes.select { |r| string =~ r }.map { |r| @regex_counts[regex] += 1; @hash[r] } 
+  #
+  # Return the first thing that matches the key.
+  #
+  def [](key)
+    all(key).first
   end
   
-  def search_strings(regex)
-    keys.select { |key| key =~ regex if key.is_a? String }.map{ |key| @hash[key] }    
-  end
+  #
+  # Return everything that matches the query.
+  #
+  def all(query)
+    return Enumerator.new(self, :all, query) unless block_given?   
   
-  def [](key)
-    return @hash[key] if @hash.include? key
+    if @hash.include? query
+      yield @hash[query]
+      return
+    end
 
-    case key
-      
-      when String
-        optimize_if_necessary!
-        
-        regexes = @regexes.select { |r| r =~ key }
-        
-        if regexes.any?
-          return regexes.map do |regex|
-            @regex_counts[regex] += 1 
-            @hash[regex]  
+    case query
+    when String
+      optimize_if_necessary!
+      @regexes.each do |regex|
+        if match = regex.match(query)
+          @regex_counts[regex] += 1
+          value = @hash[regex]
+          if value.responds_to? :call
+            yield value.call(match)
+          else
+            yield value
           end
         end
-        
-      when Regexp
-        
-        matches = search_strings(key)
-        
-        if matches.any?
-          return matches
-        end
+      end
       
-    else
-      return @hash[key]
-    end
-
-    nil
-  end
+    when Integer
+      @ranges.each do |range| 
+        yield @hash[range] if range.include? query
+      end
+    
+    when Regexp
+      # TODO: this doesn't seem very useful. should I ditch it? let me know!
+      @hash.each do |key,val|
+        yield val if key.is_a? String and query =~ key 
+      end
   
-  def update(other)
-    for key, value in other
-      self[key] = value
     end
-    self
+    
   end
   
   def method_missing(*args, &block)

data/lib/epitools/term.rb

@@ -54,7 +54,7 @@ module Term
   
     def initialize(data, options={})
       @data         = data.map(&:to_s)
-      @strip_color = options[:strip_color] || options[:strip_ansi]
+      @strip_color = options[:ansi] || options[:colorized] || options[:colored] || options[:strip_color] || options[:strip_ansi]
 
       if strip_color
         @max_size = @data.map { |e| e.strip_color.size }.max
@@ -116,6 +116,10 @@ module Term
       render sliced_into(num_columns)
     end
     
+    def to_s
+      by_rows
+    end
+    
     def render(rows, options={})
       num_cols  = rows.first.size
       result    = []

data/spec/{basetypes_spec.rb → core_ext_spec.rb}

@@ -17,27 +17,35 @@ describe Object do
     c = Cookie.new; c.size = 10; c.chips = 200
     w = c.with(:chips=>50)
     
-    w.size.should == c.size
+    w.size.should      == c.size
     w.chips.should_not == c.chips
-    w.should_not === c
+    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
+    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 "benches" do
+  it "times" do
     lambda { 
-      bench("benchmark test") { x = 10 }
+      time("time test") { x = 10 }
     }.should_not raise_error
 
     lambda { 
-      bench("benchmark test") { raise "ERROR" }
+      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
+    lambda { bench                          }.should raise_error
+    lambda { bench(:rand => proc { rand }, :notrand => proc { 1 })        }.should_not raise_error
+    lambda { bench(200, :rand => proc { rand }, :notrand => proc { 1 })   }.should_not raise_error
+  end
 
   it "trys" do
     s = Struct.new(:a,:b).new
@@ -53,21 +61,21 @@ describe Object do
 
     def s.test(a); a; end
     
-    s.test(1).should == 1
-    s.try(:test, 1).should == 1
+    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.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.even?.should     == true
     10.not.even?.should == false
   end
   
@@ -123,33 +131,47 @@ end
 describe Numeric do
 
   it "commatizes" do
-    123.commatize.should == "123"
-    1234.commatize.should == "1,234"
-    12983287123.commatize.should == "12,983,287,123"
-    -12983287123.commatize.should == "-12,983,287,123"
+    123.commatize.should               == "123"
+    1234.commatize.should              == "1,234"
+    12983287123.commatize.should       == "12,983,287,123"
+    -12983287123.commatize.should      == "-12,983,287,123"
     -12983287123.4411.commatize.should == "-12,983,287,123.4411"
   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.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 
     5.days.from_now.to_i.should == (Time.now + 5.days).to_i
   end
   
-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]
+    -1.things.should             == []
+  end
 
+  it "maths" do
+    10.cos.should == Math.cos(10)
+    20.sin.should == Math.sin(20)
+    1.5.exp.should == Math.exp(1.5)
+
+    253.log(5).should == Math.log(253,5)
+    (2**(4212.log(2))).should == 4212.0
+  end
+
+end
 
 describe String do
   
   it "rot13s" do
     message = "Unbreakable Code"
-    message.rot13.should_not == message
+    message.rot13.should_not   == message
     message.rot13.rot13.should == message
   end
   
@@ -205,6 +227,14 @@ describe String do
     "blahblahblah".startswith("blah").should == true    
     "blahblahblah".endswith("blah").should == true    
   end
+
+  it "amounts" do
+    "cookie".amount(5).should == "5 cookies"
+    "cookie".amount(0).should == "0 cookies"
+    "shirt".amount(17).should == "17 shirts"
+    "dollar".amount(-10).should == "-10 dollars"
+    "love".amount(1).should == "1 love"
+  end
   
 end
 
@@ -304,6 +334,11 @@ describe Array do
     (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
 
 
@@ -346,10 +381,17 @@ describe Enumerable do
     [1,1,3,3].average.should == 2.0
   end
 
-  it "recursively maps" do
-    [[1,2],[3,4]].recursive_map {|e| e ** 2}.should == [[1,4],[9,16]] 
-    [1,2,3,4].recursive_map {|e| e ** 2}.should == [1,4,9,16] 
-    [[],[],1,2,3,4].recursive_map {|e| e ** 2}.should == [[], [], 1, 4, 9, 16] 
+  it "maps deeply" do
+    [[1,2],[3,4]].deep_map {|e| e ** 2}.should == [[1,4],[9,16]] 
+    [1,2,3,4].deep_map {|e| e ** 2}.should == [1,4,9,16] 
+    [[],[],1,2,3,4].deep_map {|e| e ** 2}.should == [[], [], 1, 4, 9, 16] 
+  end
+  
+  it "selects deeply" do
+    [[1,2],[3,4]].deep_select {|e| e % 2 == 0 }.should == [2,4] 
+    {1=>2, 3=>{4=>5, 6=>7}}.deep_select {|k,v| k == 1 }.should == {1=>2} 
+    #[1,2,3,4].deep_select {|e| e ** 2}.should == [1,4,9,16] 
+    #[[],[],1,2,3,4].deep_select {|e| e ** 2}.should == [[], [], 1, 4, 9, 16] 
   end
   
   it "foldl's" do
@@ -374,6 +416,12 @@ describe Enumerable do
     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
+  
 end
 
 describe Hash do
@@ -384,24 +432,25 @@ describe Hash do
     
   it "maps keys" do
     h = @h.map_keys{|k| k.upcase}
-    h.keys.should == @h.keys.map{|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]
+    h.keys.should   == [1]
   end
   
   it "maps values" do
     h = @h.map_values{|v| v.upcase}
+
     h.values.should == @h.values.map{|v| v.upcase}
-    h.keys.should == @h.keys
-    h.map_values!{ 1 }
+    h.keys.should   == @h.keys
+    h.map_values! { 1 }
     h.values.should == [1,1]
   end
   
   it "mkdir_p's and trees" do
     h = {}
-    h.mkdir_p(["a", "b", "c"]).should == {"a"=>{"b"=>{"c"=>{}}}}
+    h.mkdir_p(["a", "b", "c"]).should    == {"a"=>{"b"=>{"c"=>{}}}}
     h.mkdir_p(["a", "b", "whoa"]).should == {"a"=>{"b"=>{"c"=>{}, "whoa"=>{}}}}
     
     lambda { 
@@ -416,6 +465,63 @@ describe Hash do
     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
+  end
+  
+end
+
+
+describe Time do
+  it "time in words" do
+    Time.now.in_words.should           == "just now"
+    1.second.ago.in_words.should       == "1 second ago"
+    2.seconds.ago.in_words.should      == "2 seconds ago"
+    3.weeks.ago.in_words.should        == "3 weeks ago"
+    4.5.weeks.ago.in_words.should      == "1 month ago"
+    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
+
+
+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
+end
+
+describe Proc do
+
+  it "joins procs" do
+    a = proc { 1 } & proc { 2 }
+    a.call.should == [1,2]
+
+    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 
+  end
+    
 end
 
 
@@ -427,6 +533,14 @@ describe BasicObject do
   
 end
 
+describe Range do
+
+  it "generates random numbers" do
+    r = 1..10
+    50.times { r.includes?(r.rand).should == true }
+  end
+
+end
 
 describe "truthiness" do
   
@@ -449,6 +563,22 @@ describe "truthiness" do
   
 end
 
+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
+
+end
+
 
 describe "metaclass" do
 
@@ -460,3 +590,26 @@ describe "metaclass" do
 
 end
 
+
+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
+
+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 = {:a=>"b", 1=>true, "hello"=>[1,2,3,4,5]}
+  data.to_yaml.from_yaml.should == data  
+end
+