davidrichards-sirb 0.6.14

data/spec/lib/overrides/file_spec.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+describe File do
+  it "should have a mkdir_p method, that only creates a directory if it's missing" do
+    file = "/tmp/" + (1..3).map {|x| rand(100).to_s}.join("_")
+    File.should_not be_exist(file)
+    File.mkdir_p(file)
+    File.should be_exist(file)
+    File.should be_directory(file)
+    `rm -rf #{file}` # File.unlink wants other permissions, not bothering with that.
+    File.should_not be_exist(file)
+  end
+end

data/spec/lib/overrides/module_spec.rb

@@ -0,0 +1,86 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+describe Module do
+  it "should have alias_method_chain" do
+    class A
+      def go
+        'go'
+      end
+      def go_with_flair
+        go_without_flair + " flair"
+      end
+      alias_method_chain :go, :flair
+    end
+    a = A.new
+    a.go.should eql('go flair')
+    a.go_without_flair.should eql('go')
+    Object.send(:remove_const, :A)
+  end
+  
+  it "should have archive_method" do
+    class A
+      archive_method(:go)
+    end
+    a = A.new
+    a.methods.should_not be_include('go')
+    a.methods.should_not be_include('original_go')
+
+    class A
+      def go
+        'go'
+      end
+      archive_method(:go)
+      def go
+        'a new go'
+      end
+    end
+    a = A.new
+    a.methods.should be_include('go')
+    a.methods.should be_include('original_go')
+    a.go.should eql('a new go')
+    a.original_go.should eql('go')
+    Object.send(:remove_const, :A)
+
+    class A
+      def go
+        'go'
+      end
+      archive_method(:go, :different_name)
+    end
+    a = A.new
+    a.methods.should_not be_include('go')
+    a.methods.should be_include('different_name')
+    a.different_name.should eql('go')
+    Object.send(:remove_const, :A)
+
+    class A
+      def go
+        'go'
+      end
+      private :go
+      archive_method(:go, :private_go)
+    end
+    a = A.new
+    a.methods.should_not be_include('go')
+    a.private_methods.should be_include('private_go')
+    a.send(:private_go).should eql('go')
+    Object.send(:remove_const, :A)
+  end
+  
+  it "should have [] aliased for instance_method" do
+    String[:reverse].bind("hello").call.should eql("olleh")
+  end
+  
+  it "should have []= setup to define an instance method" do
+    String[:backwards] = lambda { reverse }
+    "david".backwards.should eql('divad')
+  end
+  
+  it "should have a safe way to define an instance method only if it isn't already set. (archive_method and alias_method_chain are useful here as well.)" do
+    String[:backwards2] = lambda {reverse}
+    a = "asdf"
+    a.backwards2.should eql('fdsa')
+    String.safe_def(:backwards2) { upcase }
+    a.backwards2.should eql('fdsa')
+  end
+end

data/spec/lib/overrides/symbol_spec.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+describe Symbol do
+  it "should have a shortcut for to_proc" do
+    [1,2,3].map(&:succ).should eql([2,3,4])
+  end
+  
+  it "should have [], which is a method to call :some_method on SomeObject" do
+    creator = :new[Array]
+    
+    # Longhand
+    creator.call.should be_is_a(Array)
+    creator.call.should be_empty
+
+    creator.call.object_id.should_not eql(creator.call.object_id)
+    
+    # Shorthand
+    [creator].should be_is_a(Array)
+    
+    # Parameters
+    class A
+      def initialize(value)
+        @value = value
+      end
+      attr_accessor :value
+    end
+    builder = :new[A]
+    builder.call(1).value.should eql(1)
+    builder.call(2).value.should eql(2)
+    Object.send(:remove_const, :A)
+  end
+  
+  it "should have []=, which is a method to create a method on some object" do
+    o = Object.new
+    o.should_not be_respond_to(:my_method)
+    :my_method[o] = lambda {'my method'}
+    o.my_method.should eql('my method')
+  end
+end

data/spec/lib/sirb/enumerable_statistics_spec.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+# I'm putting off the default blocks and block parameters, because I'm
+# not convinced I want to use these yet, they get very confusing very
+# fast. 
+describe EnumerableStatistics do
+  it "should find the standard deviation of a list" do
+    [1,2,3].std.should eql(1.0)
+    # Verified with R
+    [7,12,15].std.should be_close(4.041452, 0.000001)
+  end
+  
+  it "should find the variance of a list" do
+    [1,2,3].var.should eql(1.0)
+    [7,12,15].var.should be_close(16.333333, 0.000001)
+  end
+  
+  it "should find the min" do
+    [1,2,3].min.should eql(1)
+  end
+
+  it "should find the min_index" do
+    [1,2,3].min_index.should eql(0)
+  end
+
+  it "should find the max" do
+    [1,2,3].max.should eql(3)
+  end
+
+  it "should find the max_index" do
+    [1,2,3].max_index.should eql(2)
+  end
+  
+  it "should find the median" do
+    [6,2,1].median.should eql(2)
+    [6,2,1,7].median.should eql(4.0)
+  end
+  
+  it "should offer the range" do
+    [1,2,3,4,5].range.should eql([1,5])
+    [5,2,2,3,3,1,4,5].range.should eql([1,5])
+  end
+  
+  it "should offer range in a given class with range_as_range" do
+    class MyRange < Range; end
+    a = [1,2,3]
+    a.range_class = MyRange
+    a.range_as_range.should be_is_a(MyRange)
+    Object.send(:remove_const, :MyRange)
+  end
+  
+  it "should offer the rank of a list" do
+    a = [4,2,6]
+    a.rank.should eql([2,1,3])
+  end
+  
+  it "should offer the order of the list" do
+    [10,5,5,1].order.should eql([4,2,2,1])
+  end
+  
+  it "should offer the quantile of the list" do
+    # This reflects R's approach, which I don't agree with.
+    [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0].quantile.should eql([1.0, 3.25, 5.5, 7.75, 10.0])
+    [1.0, 2.0, 3.0, 4.0, 5.0].quantile.should eql([1.0, 2.0, 3.0, 4.0, 5.0])
+  end
+  
+  it "should offer a cumulative sum" do
+    [1,2,3].cum_sum.should eql([1.0, 3.0, 6.0])
+  end
+  
+  it "should offer a cumulative product" do
+    [1,2,3].cum_prod.should eql([1.0, 2.0, 6.0])
+  end
+  
+  it "should offer a cumulative max" do
+    [3,2,1].cum_max.should eql([3,3,3])
+    [1,5,3,2,1].cum_max.should eql([1,5,5,5,5])
+  end
+
+  it "should offer a cumulative max" do
+    [1,2,3].cum_min.should eql([1,1,1])
+    [5,1,3,2,1].cum_min.should eql([5,1,1,1,1])
+  end
+
+end

data/spec/lib/sirb/functional_spec.rb

@@ -0,0 +1,75 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+describe Functional do
+  it "should implement an apply method, a reverse map" do
+    a = [[1,2],[3,4]]
+    sum = lambda {|x,y| x+y}
+    sums = sum.apply(a)
+    sums.should eql([3,7])
+    sums = sum|a
+    sums.should eql([3,7])
+  end
+  
+  it "should implement a reduce method, an inverse inject" do
+    data = [1,2,3,4]
+    sum = lambda {|x,y| x+y}
+    total = sum.reduce(data)
+    total.should eql(10)
+    total = sum<=data
+    total.should eql(10)
+  end
+  
+  it "should implement a compose method" do
+    f = lambda {|x| x*x }
+    g = lambda {|x| x+1 }
+    (f.compose(g))[2].should eql(9)
+    (g.compose(f))[2].should eql(5)
+    (f*g)[2].should eql(9)
+    (g*f)[2].should eql(5)
+  end
+  
+  it "should be able to apply a value to the head of a parameters list" do
+    product = lambda {|x,y| x*y}
+    doubler = product.apply_head(2)
+    doubler.call(3).should eql(6)
+    doubler = product.apply_head(2,3)
+    doubler.call.should eql(6)
+    # doubler = product >> 2
+    # doubler.call(3).should eql(6)
+  end
+
+  it "should be able to apply a value to the tail of a parameters list" do
+    difference = lambda {|x,y| x-y }
+    decrement = difference.apply_tail(1)
+    decrement.call(5).should eql(4)
+    decrement = difference.apply_tail(5,1)
+    decrement.call.should eql(4)
+    # decrement = difference << 1
+    # decrement.call(5).should eql(4)
+  end
+  
+  it "should be able to memoize a proc" do
+    require 'benchmark'
+    Benchmark::Tms[:to_f] = lambda {to_s.split(/\(|\)/)[-2].to_f}
+    factorial = lambda {|x| return 1 if x==0; x*factorial[x-1]; }
+    memoized_factorial = factorial.memoize
+    cached_factorial = +factorial # Alias
+    m1 = Benchmark.measure {factorial.call(30)}
+    m2 = Benchmark.measure {factorial.call(30)}
+    m3 = Benchmark.measure {memoized_factorial.call(30)}
+    m4 = Benchmark.measure {memoized_factorial.call(30)}
+    m5 = Benchmark.measure {cached_factorial.call(30)}
+    
+    # They should both be about the same
+    (m1.to_f).should be_close(m2.to_f, 0.005)
+    
+    # A memoized function should be faster than a non-memoized one
+    (m2.to_f > m4.to_f).should eql(true)
+    
+    # The first one is not memoized, the second is.
+    (m3.to_f > m4.to_f).should eql(true)
+    
+    # Should both have been memoized, since they are aliases.
+    (m5.to_f).should be_close(m4.to_f, 0.005)
+  end
+end

data/spec/lib/sirb/general_statistics_spec.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+describe GeneralStatistics do
+  it "should safely create a max method (aliasing an existing max to original_max)" do
+    class CheckMaxOne
+      def max
+        'original max'
+      end
+      include GeneralStatistics
+    end
+    
+    @c = CheckMaxOne.new
+    @c.original_max.should eql('original max')
+    @c.max(1,2,3).should eql(3)
+    @c.max(1,2).should eql(2)
+    @c.max(1).should eql(1)
+    @c.max.should be_nil
+    @c.max_index(4,5,6).should eql(2)
+    Object.send(:remove_const, :CheckMaxOne)
+  end
+
+  it "should safely create a min method (aliasing an existing min to original_min)" do
+    class CheckMinOne
+      def min
+        'original min'
+      end
+      include GeneralStatistics
+    end
+    
+    @c = CheckMinOne.new
+    @c.original_min.should eql('original min')
+    @c.min(1,2,3).should eql(1)
+    @c.min(1,2).should eql(1)
+    @c.min(1).should eql(1)
+    @c.min.should be_nil
+    @c.min_index(4,5,6).should eql(0)
+    Object.send(:remove_const, :CheckMinOne)
+  end
+
+end

data/spec/lib/sirb/inter_enumerable_statistics_spec.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+describe InterEnumerableStatistics do
+  
+  it "should calculate p_max over a series of enumerables" do
+    a = [1,2,3]
+    b = [3,2,1]
+    c = [0,0,0]
+    p_max(a,b,c).should eql([3,2,3])
+  end
+  
+  it "should calculate a p_min over a series of enumerables" do
+    a = [1,2,3]
+    b = [3,2,1]
+    c = [3,3,3]
+    p_min(a,b,c).should eql([1,2,1])
+  end
+  
+  it "should create an accurate correlation between two lists" do
+    a = [1,2,3]
+    b = [1,2,3]
+    correlation(a,b).should eql(1.0)
+    cor(a,b).should eql(1.0)
+    a = [7,12,15]
+    b = [19,21,27]
+    # Verified with R
+    cor(a,b).should be_close(0.9112932, 0.0000001)
+  end
+  
+  it "should be able to call a block on pairs and then sum that up" do
+    a = [1,2,3]
+    b = [1,2,3]
+    to_pairs(a,b) { |a,b| a * b }.should eql([1, 4, 9])
+  end
+  
+  it "should be able to sum a set of pairs given a block operator" do
+    a = [1,2,3]
+    b = [1,2,3]
+    sum_pairs(a,b) { |a,b| a * b }.should eql(14.0)
+  end
+  
+  it "should be able to sum onto an arbitrary object" do
+    @a = [1,2,3]
+    @b = [1,2,3]
+    sum_pairs(@a,@b, 0) { |a,b| a * b }.should eql(14)
+    sum_pairs(@a,@b, 10) { |a,b| a * b }.should eql(24)
+  end
+  
+  it "should find the product of a list" do
+    x = [1,2,3,4]
+    product(*x).should eql(24.0)
+    product(1,2,3,4).should eql(24.0)
+  end
+  
+end

data/spec/lib/sirb/lib_loader_spec.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+describe LibLoader do
+  it "should be able to load a library by name only" do
+    lambda{LibLoader.add_lib(:md5)}.should_not raise_error
+    LibLoader.libs_loaded.should be_include('md5')
+    defined?(MD5).should eql("constant")
+  end
+  
+  it "should be able to custom define what loading means" do
+    LibLoader.add_lib(:my_load) { @two = 1 + 1 }
+    LibLoader.libs_loaded.should be_include('my_load')
+    @two.should eql(2)
+  end
+  
+  it "should have a list of all libs attempted" do
+    LibLoader.add_lib(:garbage)
+    LibLoader.all_libs.should be_include('garbage')
+  end
+  
+  it "should have read access to the libs hash" do
+    LibLoader.libs.should be_is_a(Hash)
+    lambda{LibLoader.libs = nil}.should raise_error
+  end
+  
+  it "should keep track of the libs loaded" do
+    LibLoader.add_lib(:md5)
+    LibLoader.libs_loaded.should be_include('md5')
+  end
+  
+  it "should require a raised error to count the load as a fail (not just a false value from the experience)" do
+    LibLoader.add_lib(:junk) {false}
+    LibLoader.failed_libs.should_not be_include('junk')
+    LibLoader.add_lib(:junk2)
+    LibLoader.failed_libs.should be_include('junk2')
+    LibLoader.add_lib(:junk) { raise StandardError }
+    LibLoader.failed_libs.should be_include('junk')
+  end
+end

data/spec/lib/sirb/runner_spec.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+# I haven't gotten the runner stuff worked out yet.  I'll wait until I
+# refactor Sproc, then I need to make sure this interface is 100%. 
+# describe Runner do
+#   it "should do some good...come back to this." do
+#     
+#   end
+# end

data/spec/lib/sirb/sproc/proc_spec.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), "/../../../spec_helper")
+
+describe Proc do
+  it "should be able to create a sproc from itself" do
+    p = Proc.new { 1 + 1 }
+    p.to_sproc.call.should eql(2)
+    p.to_sproc.should be_is_a(Sproc)
+  end
+end

data/spec/lib/sirb/sproc/sproc_spec.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), "/../../../spec_helper")
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../../../lib/stored_procedures"))
+
+describe Sproc do
+  it "should instantiate like a normal Proc" do
+    lambda {@s = Sproc.new {1 + 1} }.should_not raise_error
+    @s.call.should eql(2)
+  end
+  
+  it "should have an alternate constructor, build, that takes a block" do
+    lambda {@s = Sproc.build {1 + 1} }.should_not raise_error
+    @s.call.should eql(2)
+  end
+  
+  it "should have an alternate constructor, build, that takes a string" do
+    lambda {@s = Sproc.build "1 + 1" }.should_not raise_error
+    @s.should be_is_a(Sproc)
+    @s.call.should eql(2)
+  end
+  
+  it "should not let build take other kinds of parameters" do
+    lambda {@s = Sproc.build 1 }.should raise_error
+    lambda {@s = Sproc.build nil }.should raise_error
+  end
+end

data/spec/lib/sirb/unbound_method_spec.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+describe UnboundMethod do
+  it "should use [] as an alias for bind" do
+    # Long form
+    String[:reverse].bind("hello").call.should eql("olleh")
+    # Slightly shorter form
+    String[:reverse]["hello"].call.should eql("olleh")
+    # Target form
+    String[:reverse]["hello"][].should eql("olleh")
+  end
+end

data/spec/lib/sirb_spec.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+
+describe Sirb do
+  
+  it "should attempt to load the known useful mathematical and statistical libraries" do
+    LibLoader.all_libs.should be_include( *["enumerable statistics", "mathn", "matrix", "narray", "rbtree", "rgl", "rnum", "rubygems", "general statistics", "statisticus"])
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + "/../lib/sirb")
+require 'spec'
+
+include Sirb
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: davidrichards-sirb
+version: !ruby/object:Gem::Version 
+  version: 0.6.14
+platform: ruby
+authors: 
+- David Richards
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-23 00:00:00 -07:00
+default_executable: sirb
+dependencies: []
+
+description: A series of useful tools that a console should probably have, if your goal is to crunch a few numbers. It includes all the packages that I use, if you have them.  Also incorporates some functional style programming and stored procedures to make your console experience even more delightful.
+email: davidlamontrichards@gmail.com
+executables: 
+- sirb
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- VERSION.yml
+- bin/sirb
+- lib/overrides
+- lib/overrides/array.rb
+- lib/overrides/file.rb
+- lib/overrides/module.rb
+- lib/overrides/symbol.rb
+- lib/sirb
+- lib/sirb/enumerable_statistics.rb
+- lib/sirb/functional.rb
+- lib/sirb/general_statistics.rb
+- lib/sirb/inter_enumerable_statistics.rb
+- lib/sirb/lib_loader.rb
+- lib/sirb/runner.rb
+- lib/sirb/sproc
+- lib/sirb/sproc/proc.rb
+- lib/sirb/sproc/proc_source.rb
+- lib/sirb/sproc/sproc.rb
+- lib/sirb/sproc/usage_notes.txt
+- lib/sirb/sproc.rb
+- lib/sirb/thread_support.rb
+- lib/sirb/unbound_method.rb
+- lib/sirb.rb
+- lib/stored_procedures.rb
+- spec/lib
+- spec/lib/overrides
+- spec/lib/overrides/array_spec.rb
+- spec/lib/overrides/file_spec.rb
+- spec/lib/overrides/module_spec.rb
+- spec/lib/overrides/symbol_spec.rb
+- spec/lib/sirb
+- spec/lib/sirb/enumerable_statistics_spec.rb
+- spec/lib/sirb/functional_spec.rb
+- spec/lib/sirb/general_statistics_spec.rb
+- spec/lib/sirb/inter_enumerable_statistics_spec.rb
+- spec/lib/sirb/lib_loader_spec.rb
+- spec/lib/sirb/runner_spec.rb
+- spec/lib/sirb/sproc
+- spec/lib/sirb/sproc/proc_spec.rb
+- spec/lib/sirb/sproc/sproc_spec.rb
+- spec/lib/sirb/unbound_method_spec.rb
+- spec/lib/sirb_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/davidrichards/sirb
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Descriptive statistics + IRB + any other useful numerical library you may have around
+test_files: []
+