webget_ramp 1.7.1.1

data/lib/webget_ramp/yaml.rb

@@ -0,0 +1,32 @@
+require 'yaml'
+
+module YAML
+
+  # Specify one or more directory patterns and pass each YAML file in the matching directories to a block.
+  #
+  # See [Dir#glob](http://www.ruby-doc.org/core/classes/Dir.html#M002347) for pattern details.
+  #
+  # ==Example
+  #   YAML.load_dir('/tmp/*.yaml'){|yaml_document|
+  #     #...whatever you want to do with each yaml document
+  #   }
+  #
+  # ==Example to load documents in files ending in ".yaml" and ".yml"
+  #   YAML.load_dir('/tmp/*.yaml','/tmp/*.yml','){|yaml_document|
+  #     #...whatever you want to do with the yaml document
+  #   }
+  
+  def YAML.load_dir(*dirpaths)
+    dirpaths=[*dirpaths.flatten]
+    dirpaths.each do |dirpath|
+      Dir[dirpath].each do |filename|
+        File.open(filename) do |file|
+          YAML.load_documents(file) do |doc|
+            yield doc
+          end #load
+        end #file
+      end #dir
+    end #each
+  end #def
+
+end

data/test/webget_ramp/active_record/connection_adapters/abstract/schema_statements_test.rb

@@ -0,0 +1,9 @@
+require 'test/unit'
+require 'webget_ramp'
+
+class SchemaStatementsTest < Test::Unit::TestCase
+
+  def test_placeholder
+  end
+
+end

data/test/webget_ramp/active_record_test.rb

@@ -0,0 +1,64 @@
+require 'test/unit'
+require 'webget_ramp'
+require 'active_record'
+
+begin
+ require 'sqlite3'
+rescue
+ # noop because sqlite may already be available,
+ # e.g. in JRuby on Ubuntu you can install it:
+ # apt-get install libsqlite3-ruby
+end
+
+begin
+  ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+rescue
+  raise ""+
+    "ActiveRecord cannot establish connection to sqlite3 database memory.\n" +
+    "Please verify that you have the sqlite3 database installed for testing.\n" +
+    "To install it for Ruby typically do: sudo gem install sqlite3-ruby\n" + 
+    "To install it for JRuby + Ubuntu do: sudo apt-get install libsqlite3-ruby"
+end
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :foos do |t|
+    t.string :a
+    t.string :b
+    t.string :c
+  end
+end
+
+class Foo < ActiveRecord::Base
+end
+
+class ActiveRecordTest < Test::Unit::TestCase
+
+  def test_prelim_count
+    assert_equal(0,Foo.count)
+  end
+
+  def test_prelim_create
+    f=Foo.new
+    f.a='aa'
+    f.b='bb'
+    f.c='cc'
+    f.save
+    assert_equal(1,Foo.count)    
+  end
+
+  def test_seed_with_create
+    n1=Foo.count
+    Foo.seed(:a,{:a=>'xxx',:b=>'yyy'})
+    n2=Foo.count
+    assert_equal(n1+1,n2)    
+  end
+
+  def test_seed_with_update
+    n1=Foo.count
+    f1=Foo.find(:first)
+    Foo.seed(:a,{:a=>f1.a,:b=>'bbb'})
+    n2=Foo.count
+    assert_equal(n1,n2)    
+  end
+
+end

data/test/webget_ramp/array_test.rb

@@ -0,0 +1,171 @@
+require 'test/unit'
+require 'csv'
+require 'webget_ramp'
+
+class ArrayTest < Test::Unit::TestCase
+
+  def test_join
+    a=['a','b','c']
+    assert_equal('abc',a.join)
+    assert_equal('a*b*c',a.join('*'))
+    assert_equal('[a]*[b]*[c]',a.join('*','[',']'))
+    assert_equal('[a][b][c]',a.join('[',']'))
+  end
+
+  def test_size
+    assert_equal(false,[].size?)
+    assert_equal(true,[1].size?)
+    assert_equal(true,[1,2].size?)
+    assert_equal(true,[[]].size?)
+  end
+  
+ def test_rotate
+   a=[1,2,3,4]
+   a.rotate!
+   assert_equal([2,3,4,1],a)
+   a.rotate!
+   assert_equal([3,4,1,2],a)
+ end
+
+ def test_choice
+   a=[1,2,3,4]
+   c=a.choice
+   assert_equal(Fixnum,c.class)
+   assert(a.include?(c))
+ end
+
+ def test_choices
+   a=[1,2,3,4]
+   c=a.choices(2)
+   assert_equal(2,c.size)
+   assert(a.include?(c[0]))
+   assert(a.include?(c[1]))
+   c=a.choices(3)
+   assert_equal(3,c.size)
+   assert(a.include?(c[0]))
+   assert(a.include?(c[1]))
+   assert(a.include?(c[2]))
+ end
+
+ def test_onto
+   foo=[:a,:b,:c]
+   goo=[:x,:y,:z]
+   assert_equal({:a=>:x, :b=>:y, :c=>:z},foo.onto(goo))
+ end
+
+ def test_slices
+  a=[1,2,3,4,5,6,7,8]
+  assert_equal([[1,2],[3,4],[5,6],[7,8]],a.slices(2))
+  assert_equal([[1,2,3,4],[5,6,7,8]], a.slices(4))
+  assert_equal([[1,2,3],[4,5,6],[7,8]],a.slices(3))
+  assert_equal([[1,2,3,4,5],[6,7,8]],a.slices(5))
+ end
+
+ def test_divvy_evenly_divisible
+   assert_equal([[1,2,3],[4,5]],[1,2,3,4,5].divvy(2),'division with equal slices')
+   assert_equal([[1,2,3],[4,5,6],[7]],[1,2,3,4,5,6,7].divvy(3),'division with remainer slice')
+   assert_equal([[1,2],[3,4],[5,6]],[1,2,3,4,5,6].divvy(4),'division with small numbers')
+ end
+
+ def test_union
+   a=[[2,3,4],[4,5,6],[6,7,8]]
+   assert_equal([2,3,4,5,6,7,8],a.union)
+ end
+
+ def test_intersect
+   a=[[2,3,4],[4,3,5],[3,4,7]]
+   assert_equal([3,4],a.intersect)
+ end
+
+  def test_shifted
+    a=['a','b','c']
+    assert_equal([    'b','c'],a.shifted)
+    assert_equal(['a','b','c'],a.shifted(0))
+    assert_equal([    'b','c'],a.shifted(1))
+    assert_equal([        'c'],a.shifted(2))
+    assert_equal([           ],a.shifted(3))
+    assert_equal(nil          ,a.shifted(4))
+  end
+
+  # test_cdr must be idential to test_shifted
+  # because cdr is an alias for shifted
+  def test_cdr
+    a=['a','b','c']
+    assert_equal([    'b','c'],a.cdr)
+    assert_equal(['a','b','c'],a.cdr(0))
+    assert_equal([    'b','c'],a.cdr(1))
+    assert_equal([        'c'],a.cdr(2))
+    assert_equal([           ],a.cdr(3))
+    assert_equal(nil          ,a.cdr(4))
+  end
+
+  # test_rest must be idential to test_shifted
+  # because rest is an alias for shifted
+  def test_rest
+    a=['a','b','c']
+    assert_equal([    'b','c'],a.rest)
+    assert_equal(['a','b','c'],a.rest(0))
+    assert_equal([    'b','c'],a.rest(1))
+    assert_equal([        'c'],a.rest(2))
+    assert_equal([           ],a.rest(3))
+    assert_equal(nil          ,a.rest(4))
+  end
+
+  def test_shifted_bang
+    a=['a','b','c']; a.shifted!;    assert_equal([    'b','c'],a)
+    a=['a','b','c']; a.shifted!(0); assert_equal(['a','b','c'],a)
+    a=['a','b','c']; a.shifted!(1); assert_equal([    'b','c'],a)
+    a=['a','b','c']; a.shifted!(2); assert_equal([        'c'],a)
+    a=['a','b','c']; a.shifted!(3); assert_equal([           ],a)
+    a=['a','b','c']; a.shifted!(4); assert_equal([           ],a)
+  end
+
+  # alias: test_cdr_bang must be identical to test_shifted_bang
+  def test_cdr_bang
+    a=['a','b','c']; a.cdr!;    assert_equal([    'b','c'],a)
+    a=['a','b','c']; a.cdr!(0); assert_equal(['a','b','c'],a)
+    a=['a','b','c']; a.cdr!(1); assert_equal([    'b','c'],a)
+    a=['a','b','c']; a.cdr!(2); assert_equal([        'c'],a)
+    a=['a','b','c']; a.cdr!(3); assert_equal([           ],a)
+    a=['a','b','c']; a.cdr!(4); assert_equal([           ],a)
+  end
+
+  # alias: test_rest_band must be identical to test_shifted_bang
+  def test_rest_bang
+    a=['a','b','c']; a.rest!;    assert_equal([    'b','c'],a)
+    a=['a','b','c']; a.rest!(0); assert_equal(['a','b','c'],a)
+    a=['a','b','c']; a.rest!(1); assert_equal([    'b','c'],a)
+    a=['a','b','c']; a.rest!(2); assert_equal([        'c'],a)
+    a=['a','b','c']; a.rest!(3); assert_equal([           ],a)
+    a=['a','b','c']; a.rest!(4); assert_equal([           ],a)
+  end
+
+  def test_car
+    a=['a','b','c']
+    assert_equal('a',a.car)
+  end
+
+  def test_to_csv_one_dimensional
+    a=["a","b","c"]
+    assert_equal("a,b,c\n",a.to_csv)
+  end
+
+  def test_to_csv_multi_dimensional
+    a=[["a","b","c"], ["d","e","f"],["g","h","i"]]
+    assert_equal("a,b,c\nd,e,f\ng,h,i\n",a.to_csv)
+  end
+
+  def test_to_tsv
+    a=[["a", "b"], ["c", "d"], ["e", "f"]]
+    assert_equal("a\tb\nc\td\ne\tf\n",a.to_tsv)
+  end
+
+  # alias: test_to_tdf must be identical to test_to_tsv
+  def test_to_tdf
+    a=[["a", "b"], ["c", "d"], ["e", "f"]]
+    assert_equal("a\tb\nc\td\ne\tf\n",a.to_tdf)
+  end
+
+end
+
+

data/test/webget_ramp/csv_test.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require 'webget_ramp'
+
+class CSVTest < Test::Unit::TestCase
+
+ def test_http_headers
+   h=CSV.http_headers
+   assert_equal('text/csv',h["Content-Type"])
+   assert_equal("attachment; filename=\"data.csv\"",h["Content-Disposition"])
+ end
+
+ def test_http_headers_with_filename
+   h=CSV.http_headers(:filename=>'foo')
+   assert_equal('text/csv',h["Content-Type"])
+   assert_equal("attachment; filename=\"foo\"",h["Content-Disposition"])
+ end
+
+end

data/test/webget_ramp/date_test.rb

@@ -0,0 +1,60 @@
+require 'test/unit'
+require 'webget_ramp'
+
+class DateTest < Test::Unit::TestCase
+
+
+  def test_weekday
+    # Start on Monday, January 1, 2007
+    assert( Date.new(2007,1,1).weekday?) 
+    assert( Date.new(2007,1,2).weekday?)
+    assert( Date.new(2007,1,3).weekday?)
+    assert( Date.new(2007,1,4).weekday?)
+    assert( Date.new(2007,1,5).weekday?)
+    assert(!Date.new(2007,1,6).weekday?)
+    assert(!Date.new(2007,1,7).weekday?)
+    assert( Date.new(2007,1,8).weekday?)
+  end
+
+
+  def test_weekend
+    # Start on Monday, January 1, 2007
+    assert(!Date.new(2007,1,1).weekend?) 
+    assert(!Date.new(2007,1,2).weekend?) 
+    assert(!Date.new(2007,1,3).weekend?) 
+    assert(!Date.new(2007,1,4).weekend?) 
+    assert(!Date.new(2007,1,5).weekend?) 
+    assert( Date.new(2007,1,6).weekend?) 
+    assert( Date.new(2007,1,7).weekend?) 
+    assert(!Date.new(2007,1,8).weekend?) 
+  end
+
+
+  def test_to_sql
+    assert('2007-12-31',Date.new(2008,12,31))
+  end
+
+
+  # for test_age_years and test_age_days
+  BIRTHDATE     = Date.new(1980,10,31)
+  VALENTINES    = Date.new(2008,02,14)
+  HALLOWEEN     = Date.new(2008,10,31)
+  NEW_YEARS_EVE = Date.new(2008,12,31)
+
+
+  def test_age_years
+    assert_equal(27,BIRTHDATE.age_years(VALENTINES),    '< birthday')
+    assert_equal(28,BIRTHDATE.age_years(HALLOWEEN),     '= birthday')
+    assert_equal(28,BIRTHDATE.age_years(NEW_YEARS_EVE), '> birthday')
+  end
+
+
+  def test_age_days
+    assert_equal( 9967,BIRTHDATE.age_days(VALENTINES),     '< birthday')
+    assert_equal(10227,BIRTHDATE.age_days(HALLOWEEN),      '= birthday')
+    assert_equal(10288,BIRTHDATE.age_days(NEW_YEARS_EVE),  '> birthday')
+  end
+
+
+end
+

data/test/webget_ramp/enumerable_test.rb

@@ -0,0 +1,271 @@
+require 'test/unit'
+require 'webget_ramp'
+require 'set'
+
+class EnumerableTest < Test::Unit::TestCase
+
+  ITEMS = ['a','b','c']
+  MAPTEST = [123,"456"]
+  RGB = ["red","green","blue"]  
+
+
+  ########################################################################
+  #
+  #  typecast
+  #
+  ########################################################################
+
+
+  def test_to_h_with_unique_keys
+    a=[[:a,:b],[:c,:d],[:e,:f]] 
+    assert_equal({:a=>:b, :c=>:d, :e=>:f}, a.to_h)
+  end
+
+  def test_to_h_with_duplicate_keys
+    a=[[:a,:b],[:a,:c],[:a,:d]] 
+    assert_equal({:a=>[:b, :c, :d]}, a.to_h)
+  end
+
+  def test_index_by
+    assert_equal({3=>"red",4=>"blue",5=>"green"},RGB.index_by{|x| x.size})
+  end
+
+  def test_hash_by
+    assert_equal({3=>"Red",4=>"Blue",5=>"Green"},RGB.hash_by{|x| [x.size,x.titlecase]})
+  end
+
+    
+  ########################################################################
+  #
+  #  map
+  #
+  ########################################################################
+
+
+  class Mock #:nodoc: all
+    attr_accessor :id
+
+    def initialize(id)
+      @id=id
+    end
+
+    def to_a
+     [self]
+    end
+
+  end
+
+
+  A = Mock.new('a') 
+  B = Mock.new('b') 
+  C = Mock.new('c') 
+
+  
+  def test_map_id
+    assert_equal(['a','b','c'],[A,B,C].map_id)
+  end
+
+  def test_map_to_a
+    assert_equal([[123],["456"]],MAPTEST.to_set.map_to_a)
+  end
+
+  def test_map_to_f
+    assert_equal([123.0,456.0],MAPTEST.map_to_f)
+  end
+
+  def test_map_to_i
+    assert_equal([123,456],MAPTEST.map_to_i)
+  end
+
+  def test_map_to_s
+    assert_equal(["123","456"],MAPTEST.map_to_s)
+  end
+
+  def test_map_to_sym
+    assert_equal([:a,:b,:c],ITEMS.map_to_sym)
+  end
+
+
+  ########################################################################
+  #
+  #  select
+  #
+  ########################################################################
+
+
+  def test_select_while
+    assert_equal([           ],ITEMS.select_while{|x| x < 'a' },'< a')
+    assert_equal(['a'        ],ITEMS.select_while{|x| x < 'b' },'< b')
+    assert_equal(['a','b'    ],ITEMS.select_while{|x| x < 'c' },'< c')
+    assert_equal(['a','b','c'],ITEMS.select_while{|x| x < 'd' },'< d')
+    assert_equal(['a','b','c'],ITEMS.select_while{|x| x < 'e' },'< e')
+  end
+
+
+  def test_select_until_condition
+    assert_equal([           ],ITEMS.select_until{|x| x == 'a' },'a')
+    assert_equal(['a'        ],ITEMS.select_until{|x| x == 'b' },'b')
+    assert_equal(['a','b'    ],ITEMS.select_until{|x| x == 'c' },'c')
+    assert_equal(['a','b','c'],ITEMS.select_until{|x| x == 'd' },'d')
+    assert_equal(['a','b','c'],ITEMS.select_until{|x| x == 'e' },'e')
+  end
+
+
+  def test_select_with_index
+    assert_equal([           ],ITEMS.select_with_index{|x,i| i < 0 },'i < 0')
+    assert_equal(['a'        ],ITEMS.select_with_index{|x,i| i < 1 },'i < 1')
+    assert_equal(['a','b'    ],ITEMS.select_with_index{|x,i| i < 2 },'i < 2')
+    assert_equal(['a','b','c'],ITEMS.select_with_index{|x,i| i < 3 },'i < 3')
+    assert_equal(['a','b','c'],ITEMS.select_with_index{|x,i| i < 4 },'i < 4')
+  end
+
+
+  ########################################################################
+  #
+  #  bisect
+  #
+  ########################################################################
+
+  def test_bisect
+    assert_equal([[           ],['a','b','c']],ITEMS.bisect{|x| x < 'a' },'< a')
+    assert_equal([['a'        ],[    'b','c']],ITEMS.bisect{|x| x < 'b' },'< b')
+    assert_equal([['a','b'    ],[        'c']],ITEMS.bisect{|x| x < 'c' },'< c')
+    assert_equal([['a','b','c'],[           ]],ITEMS.bisect{|x| x < 'd' },'< d')
+  end
+
+
+  ########################################################################
+  #
+  #  nitems
+  #
+  ########################################################################
+
+
+  def test_nitems_while  
+    assert_equal(0,ITEMS.nitems_while{|x| x < 'a' },'< a')
+    assert_equal(1,ITEMS.nitems_while{|x| x < 'b' },'< b')
+    assert_equal(2,ITEMS.nitems_while{|x| x < 'c' },'< c')
+    assert_equal(3,ITEMS.nitems_while{|x| x < 'd' },'< d')
+    assert_equal(3,ITEMS.nitems_while{|x| x < 'e' },'< e')
+  end
+
+
+  def test_nitems_until
+    assert_equal(0,ITEMS.nitems_until{|x| x == 'a' },'a')
+    assert_equal(1,ITEMS.nitems_until{|x| x == 'b' },'b')
+    assert_equal(2,ITEMS.nitems_until{|x| x == 'c' },'c')
+    assert_equal(3,ITEMS.nitems_until{|x| x == 'd' },'d')
+    assert_equal(3,ITEMS.nitems_until{|x| x == 'e' },'e')
+  end
+
+  
+  def test_nitems_with_index
+    assert_equal(0,ITEMS.nitems_with_index{|x,i| i < 0 },'i < 0')
+    assert_equal(1,ITEMS.nitems_with_index{|x,i| i < 1 },'i < 1')
+    assert_equal(2,ITEMS.nitems_with_index{|x,i| i < 2 },'i < 2')
+    assert_equal(3,ITEMS.nitems_with_index{|x,i| i < 3 },'i < 3')
+    assert_equal(3,ITEMS.nitems_with_index{|x,i| i < 4 },'i < 4')
+  end
+
+
+  ########################################################################
+  #
+  #  strings
+  #
+  ########################################################################
+
+
+  def test_join_0
+    a=['a','b','c']
+    assert_equal("abc",a.join,"join()")
+  end
+
+  def test_join_1
+    a=['a','b','c']
+    assert_equal("a+b+c",a.join('+'),"join('+')")
+  end
+
+  def test_join_2
+    a=['a','b','c']
+    assert_equal("+a-+b-+c-",a.join("+","-"),"join('+','-')")
+  end
+
+
+  ########################################################################
+  #
+  #  set math
+  #
+  ########################################################################
+
+  def test_intersect_true
+    assert_equal(true,['a','b'].intersect?(['b','c']))
+  end
+
+  def test_intersect_true_with_same
+    assert_equal(true,['a','b'].intersect?(['a','b']))
+  end
+
+  def test_intersect_false
+    assert_equal(false,['a','b'].intersect?(['c','d']))
+  end
+
+  def test_intersect_false_with_none
+    assert_equal(false,['a','b','c'].intersect?([]))
+  end
+
+  CARTESIAN_PRODUCT_EXPECT=[["a", "d", "g"],
+                            ["a", "d", "h"],
+                            ["a", "d", "i"],
+                            ["a", "e", "g"],
+                            ["a", "e", "h"],
+                            ["a", "e", "i"],
+                            ["a", "f", "g"],
+                            ["a", "f", "h"],
+                            ["a", "f", "i"],
+                            ["b", "d", "g"],
+                            ["b", "d", "h"],
+                            ["b", "d", "i"],
+                            ["b", "e", "g"],
+                            ["b", "e", "h"],
+                            ["b", "e", "i"],
+                            ["b", "f", "g"],
+                            ["b", "f", "h"],
+                            ["b", "f", "i"],
+                            ["c", "d", "g"],
+                            ["c", "d", "h"],
+                            ["c", "d", "i"],
+                            ["c", "e", "g"],
+                            ["c", "e", "h"],
+                            ["c", "e", "i"],
+                            ["c", "f", "g"],
+                            ["c", "f", "h"],
+                            ["c", "f", "i"]]
+
+  def test_cartesian_product_class_method
+    a1=['a','b','c']
+    a2=['d','e','f']
+    a3=['g','h','i']
+    actual=Enumerable.cartesian_product(a1,a2,a3)
+    assert_equal(CARTESIAN_PRODUCT_EXPECT,actual,'class method')
+  end
+
+  def test_cartesian_product_instance_method
+    a1=['a','b','c']
+    a2=['d','e','f']
+    a3=['g','h','i']
+    actual=a1.cartesian_product(a2,a3)
+    assert_equal(CARTESIAN_PRODUCT_EXPECT,actual,'instance method')
+  end
+
+  def test_power_set
+    a=['a','b','c']
+    expect=[[],['a'],['a','b'],['a','b','c'],['a','c'],['b'],['b','c'],['c']]
+    actual=a.power_set.sort
+    assert_equal(expect,actual)
+  end
+
+end
+
+
+
+