epitools 0.1.1

data/lib/epitools/rails.rb

@@ -0,0 +1,11 @@
+if defined? Rails
+  
+  class ActiveRecord::Base
+    def self.[](n)
+      find n
+    end
+  end
+  
+end
+
+

data/lib/epitools/rash.rb

@@ -0,0 +1,92 @@
+#
+# A Regex-queryable Hash
+#
+class Rash
+  
+  attr_accessor :optimize_every
+  
+  def initialize(initial={})
+    @hash           = {}
+    @regexes        = []
+    @regex_counts   = Hash.new(0)
+    @optimize_every = 500
+    @lookups        = 0
+    
+    update(initial)
+  end
+
+  def []=(key, value)
+    if key.is_a? Regexp
+      key = normalize_regex(key)
+      @regexes << key
+    end
+    @hash[key] = value
+  end
+  
+  def search_regexes(string)
+    @regexes.select { |r| string =~ r }.map { |r| @regex_counts[regex] += 1; @hash[r] } 
+  end
+  
+  def search_strings(regex)
+    keys.select { |key| key =~ regex if key.is_a? String }.map{ |key| @hash[key] }    
+  end
+  
+  def [](key)
+    return @hash[key] if @hash.include? key
+
+    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]  
+          end
+        end
+        
+      when Regexp
+        
+        matches = search_strings(key)
+        
+        if matches.any?
+          return matches
+        end
+      
+    else
+      return @hash[key]
+    end
+
+    nil
+  end
+  
+  def update(other)
+    for key, value in other
+      self[key] = value
+    end
+    self
+  end
+  
+  def method_missing(*args, &block)
+    @hash.send(*args, &block)
+  end
+
+private
+
+  def optimize_if_necessary!
+    if (@lookups += 1) >= @optimize_every    
+      @regexes = @regex_counts.sort_by { |regex,count| -count }.map { |regex,count| regex }
+      @lookups = 0
+    end
+  end
+
+  def normalize_regex(regex)
+    #/^#{regex}$/
+    regex
+  end
+  
+end
+

data/spec/basetypes_spec.rb

@@ -0,0 +1,163 @@
+require 'epitools/basetypes'
+
+
+describe Object do
+  
+  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 "benches" do
+    lambda { 
+      bench("benchmark test") { x = 10 }
+    }.should_not raise_error
+
+    lambda { 
+      bench("benchmark test") { raise "ERROR" }
+    }.should raise_error
+  end
+
+  it "trys" do
+    s = Struct.new(:a,:b).new
+    s.a = 5
+    s.b = 10
+    
+    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
+  
+end
+
+
+describe Integer do
+  
+  it "integer?" do
+    
+    {
+      nil => false,
+      "123" => true,
+      "000" => true,
+      123 => true,
+      123.45 => true,
+      "123asdf" => false,
+      "asdfasdf" => false,
+      Object.new => false,
+      
+    }.each do |object, expected_result|
+      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]
+  end
+  
+end
+
+
+describe Array do
+  
+  it "squashes" do
+    [1,2,[3,4,[5],[],[nil,nil],[6]]].squash.should == [1,2,3,4,5,6]
+  end
+  
+end
+
+
+describe Enumerable do
+
+  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]]
+    [1,2,3,4,5].split_before{|e| e == 3}.should   == [[1,2],[3,4,5]]
+
+    "a\nb\n---\nc\nd\n".split_at(/---/).map_recursive(&:strip).should   == [ %w[a b], %w[c d] ]
+  end
+
+  it "sums" do
+    [1,2,3,4,5].sum.should == 15
+  end
+  
+  it "averages" do
+    [1,3].average.should == 2.0
+    [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] 
+  end
+  
+  it "foldl's" do
+    a = [1,2,3,4]
+    a.foldl(:+).should == a.sum
+    %w[hi there].foldl(:+).should == "hithere"
+  end
+  
+end
+
+describe Hash do
+
+  before :each do
+    @h = {"key1"=>"val1", "key2"=>"val2"}
+  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}
+    h.values.should == @h.values.map{|v| v.upcase}
+    h.keys.should == @h.keys
+    h.map_values!{ 1 }
+    h.values.should == [1,1]
+  end
+  
+end
+
+
+describe BlankSlate do
+  
+  it "is blank!" do
+    BlankSlate.methods(false).should == []
+  end
+  
+end
+  

data/spec/lcs_spec.rb

@@ -0,0 +1,23 @@
+require 'epitools/lcs'
+
+describe "Longest common subsequence" do
+  
+  it "works!" do
+    prefix_strings = [
+     "shenanigans, gentlemen!",
+      "shenanigans has been called",
+      "shenanigans: a great restaurant."
+    ]
+    
+    subsequence_strings = [
+      "i call shenanigans on you!",
+      "shenanigans is a great restaurant.",
+      "you like this? shenanigans!"
+    ]
+  
+    longest_common_prefix(prefix_strings).should == "shenanigans"
+    longest_common_subsequence(*subsequence_strings[0..1]).should == 12
+  end    
+  
+end
+

data/spec/metaclass_spec.rb

@@ -0,0 +1,12 @@
+require 'epitools/metaclass'
+
+describe "Metaclass" do
+  
+  it "metaclass" do
+    o = Object.new
+    o_metaclass = class << o; self; end
+    o.metaclass.should == o_metaclass
+  end    
+  
+end
+

data/spec/permutations_spec.rb

@@ -0,0 +1,14 @@
+require 'epitools/basetypes'
+require 'epitools/permutations'
+
+describe "Permutations" do
+  
+  it "a*b" do
+    ([1,2] * [3,4]).should == [ [1,3], [1,4], [2,3], [2,4] ]
+  end    
+
+  it "a**2" do
+    ([1,2] ** 2).should == [ [1,1], [1,2], [2,1], [2,2] ]
+  end    
+  
+end

data/spec/rash_spec.rb

@@ -0,0 +1,34 @@
+require 'epitools/rash'
+
+describe Rash do
+
+  attr_accessor :r
+  
+  before :each do
+    @r = Rash.new(
+      /hello/ => "hello",
+      /world/ => "world",
+      "other" => "whee",
+      true    => false,
+      1       => "awesome"
+      # /.+/ => "EVERYTHING"
+    )
+  end
+  
+  it "string lookups" do
+    r["other"].should == "whee"
+    r["well hello there"].should == ["hello"]
+    r["the world is round"].should == ["world"]
+    r["hello world"].sort.should == ["hello", "world"]
+  end
+
+  it "regex lookups" do
+    r[/other/].should == ["whee"]
+  end
+
+  it "other objects" do  
+    r[true].should == false
+    r[1].should == "awesome"
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,5 @@
+--color
+--format specdoc
+--loadby mtime
+--reverse
+

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+#require 'epitools'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: epitools
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- epitron
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-15 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+description: Miscellaneous utility libraries to make my life easier.
+email: chris@ill-logic.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/epitools.rb
+- lib/epitools/basetypes.rb
+- lib/epitools/hexdump.rb
+- lib/epitools/http.rb
+- lib/epitools/lcs.rb
+- lib/epitools/metaclass.rb
+- lib/epitools/niceprint.rb
+- lib/epitools/permutations.rb
+- lib/epitools/pretty_backtrace.rb
+- lib/epitools/rails.rb
+- lib/epitools/rash.rb
+- spec/basetypes_spec.rb
+- spec/lcs_spec.rb
+- spec/metaclass_spec.rb
+- spec/permutations_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/epitron/epitools
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: NOT UTILS... METILS!
+test_files: 
+- spec/lcs_spec.rb
+- spec/rash_spec.rb
+- spec/metaclass_spec.rb
+- spec/permutations_spec.rb
+- spec/spec_helper.rb
+- spec/basetypes_spec.rb