webget_ruby_ramp 1.7.2 → 1.7.3

data/lib/webget_ruby_ramp.rb

@@ -1,39 +1,21 @@
 =begin rdoc
 
-= WebGet Ruby Gem: Ramp is a toolkit of methods to ramp up your Ruby On Rails applications
+= WebGet Ruby Gem: Ramp is a toolkit of Ruby base class extensions
 
 Author:: Joel Parker Henderson, joelparkerhenderson@gmail.com
 Copyright:: Copyright (c) 2006-2010 Joel Parker Henderson
 License:: CreativeCommons License, Non-commercial Share Alike
 License:: LGPL, GNU Lesser General Public License
 
-Ramp is a library of extensions to Ruby and Rails base classes, including ActiveRecord, Array, Date, Enumerable, Hash, Kernel, Numeric, Object, Process, String, Time, and YAML. 
+Ramp is a library of extensions to Ruby base classes, including Array, Date, Enumerable, Hash, Kernel, Numeric, Object, Process, String, Time, and YAML. 
 
 Testing: 
 <ul>
 <li>Each has an associated test class, e.g., ArrayTest, DateTest, etc.
-<li>The easy way to run the tests: gem install ramp --test
-<li>Some of the ActiveRecord extensions use sqlite for testing. We don't install sqlite automatically because it requires some native extensions. If you need sqlite: gem install sqlite3-ruby
+<li>The easy way to run the tests: gem install webget_ruby_ramp --test
 </ul>
 
 
-== ActiveRecord
-
-* create_or_update_by: create a record, or update a record if value passed matches a field (or fields) in the AR object; includes method_missing function to make code more readable. 
-* seed: syntactic sugar alias for #create_or_update_by
-
-
-== ActiveRecord::ConnectionAdapters::SchemaStatements
-
-* add_column_and_index: database migration helper to add a table column and index at the same time.
-* remove_column_and_index: database migration helper to add a table column and index at the same time.
-
-
-== ActiveRecord::SaveExtensions
-
-* save_false_then_reload!: a transaction to save and reload a record, to help repair associations
-
-
 == Array
 
 * car, cdr: aka first, rest (see shifted)
@@ -205,7 +187,8 @@ Extensions that help debug Ruby programs.
 
 == Changes
 
-- 1.7.2 Genmcutter update
+- 1.7.3 Refactor Rails classes to their own gem
+- 1.7.2 Gemcutter update
 - 1.7.1.8 Add Enumerable#map_with_index
 - 1.7.1.6 Add ActiveRecord::SaveExtensions#save_false_then_reload!
 - 1.7.1.3 Add XML#strip_xxx 
@@ -244,7 +227,7 @@ Extensions that help debug Ruby programs.
 
 =end
 
-%w{active_record active_record/save_extensions array csv date enumerable file hash integer io kernel math nil numeric object process string symbol time xml yaml}.map{|x|
+%w{array csv date enumerable file hash integer io kernel math nil numeric object process string symbol time xml yaml}.map{|x|
   require File.dirname(__FILE__) + "/webget_ruby_ramp/#{x}.rb"
 }
 

data/lib/webget_ruby_ramp/array.rb

@@ -34,14 +34,14 @@ class Array
     when 2
       prefix=fixes[0].to_s
       suffix=fixes[1].to_s
-      return self.map{|s| prefix + s.to_s + suffix}.ruby_join()
+      return self.map{|item| prefix + item.to_s + suffix}.ruby_join()
     when 3
       infix =fixes[0].to_s
       prefix=fixes[1].to_s
       suffix=fixes[2].to_s
-      return map{|s| prefix + s.to_s + suffix}.ruby_join(infix)
+      return self.map{|item| prefix + item.to_s + suffix}.ruby_join(infix)
     else
-      raise "join(fixes[#{fixes.size}]"
+      raise ArgumentError, "join() takes 0-3 arguments; you gave #{fixes.size}]"
     end
   end
 
@@ -62,11 +62,14 @@ class Array
   # ==Examples
   #   [1,2,3,4].rotate! => [2,3,4,1]
   #   ['a','b','c'].rotate! => ['b','c','a']
+  #   [].rotate! => []
   #
   # Return self
   
   def rotate!
-    push item=shift
+    if size>0
+      push item=shift
+    end
     self
   end
 
@@ -109,6 +112,7 @@ class Array
   # This is identical to calling foo.zip(values).to_h
 
   def onto(values)
+    size==values.size or raise ArgumentError, "Array size #{size} must match values size #{size}" 
     zip(values).to_h
   end
 
@@ -133,11 +137,13 @@ class Array
   #   [1,2,3,4,5,6,7,8].slices(5) => [[1,2,3,4,5],[6,7,8]] 
 
   def slices(slice_length)
+    (slice_length.is_a? Integer) or (raise ArgumentError, "slice_length must be an integer")
+    (slice_length > 0) or (raise ArgumentError, "slice_length must be > 0")
     arr=[]
-    i=0
-    while i<length
-      arr.push self[i...(i+slice_length)]
-      i+=slice_length
+    index=0
+    while index<length
+      arr.push self[index...(index+slice_length)]
+      index+=slice_length
     end
     return arr
   end
@@ -162,6 +168,8 @@ class Array
   #   [1,2,3,4,5,6].divvy(4) => [[1,2],[3,4],[5,6]]
 
   def divvy(number_of_slices)
+    (number_of_slices.is_a? Integer) or (raise ArgumentError, "number_of_slices must be an integer")
+    (number_of_slices > 0) or (raise ArgumentError, "number_of_slices must be > 0")
     return slices((length.to_f/number_of_slices.to_f).ceil)
   end
 
@@ -177,22 +185,18 @@ class Array
   # In typical use, each item is an array.
   #
   # ==Example using Ruby Array pipe
-  #   a=[1,2,3]
-  #   b=[2,3,4]
-  #   a | b => [1,2,3,4]
-  #
-  # ==Example using union method
-  #   arr=[a,b]
-  #   => [1,2,3,4]
+  #   arr=[[1,2,3,4],[3,4,5,6]]
+  #   arr.union => [1,2,3,4,5,6]
   #
-  # This is identical to 
-  
   # ==Examples with proc
   #   arr.map(&:foo).union
   #   => foos that are in any of the array items
+  #
+  # ==Example with nil
+  #   [].union => []
 
   def union
-    inject{|inj,item| inj | item.to_a }
+    inject{|inj,item| inj | item.to_a } || []
   end
 
 
@@ -200,16 +204,19 @@ class Array
   # In typical usage, each item is an array.
   #
   # ==Examples
-  #   arr=[[1,2,3,4],[2,3,4,5],[3,4,5,6]]
+  #   arr=[[1,2,3,4],[3,4,5,6]]
   #   arr.intersect
   #   => [3,4]
   #
   # ==Examples with proc
   #   arr.map(&:foo).intersect
   #   => foos that are in all of the array items
+  #
+  # ==Example with nil
+  #   [].intersect => []
 
   def intersect
-    inject{|inj,item| inj & item.to_a }
+    inject{|inj,item| inj & item.to_a } || []
   end
 
   
@@ -243,7 +250,9 @@ class Array
   #
 
   def shifted(number_of_items=1)
-   slice(n,self.length-number_of_items)
+    (number_of_items.is_a? Integer) or (raise ArgumentError, "number_of_items must be an integer")
+    (number_of_items >= 0) or (raise ArgumentError, "number_of_items must be >= 0")
+    slice(number_of_items,self.length-number_of_items)
   end
 
   alias :car :first
@@ -266,8 +275,10 @@ class Array
   # If _n_ is greater than the array size, then return []
 
   def shifted!(number_of_items=1)
-   slice!(0,number_of_items)
-   return self
+    (number_of_items.is_a? Integer) or (raise ArgumentError, "number_of_items must be an integer")
+    (number_of_items >= 0) or (raise ArgumentError, "number_of_items must be >= 0")
+    slice!(0,number_of_items)
+    return self
   end
 
   alias :cdr! :shifted!
@@ -333,11 +344,17 @@ class Array
   #
   #   [[1,2,3],[4,5,6]] => "1,2,3\n4,5,6\n"
   #
+  # ==Example of a blank array
+  #   
+  #   [].to_csv => ""
+  #
   # N.b. this method uses the multi-dimensional if the
   # array's first item is also an array.
 
   def to_csv(ops={})
 
+    return "" if size==0
+
     generator = RUBY_VERSION >= "1.9" ? CSV : CSV::Writer
 
     str=''
@@ -360,6 +377,10 @@ class Array
   # representation of a multi-dimensional array.
   #
   # Each subarray becomes one 'line' in the output.
+  #
+  # ==Example of a blank array
+  #   
+  #   [].to_csv => ""
 
   def to_tsv(ops={})
     self.map{|row| row.join("\t")+"\n"}.join

data/lib/webget_ruby_ramp/enumerable.rb

@@ -23,22 +23,22 @@ module Enumerable
   #   array.to_h => {:a=>[:b, :c, :d]}
 
   def to_h
-    h={}
+    hash={}
     dupe={}
-    each{|k,v|
-      if h.key? k
-        if dupe.key? k
-          h[k] << v
+    each{|key,val|
+      if hash.key? key
+        if dupe.key? key
+          hash[key] << val
         else
-          h[k]=[h[k]]
-          h[k] << v          
-          dupe[k]=true
+          hash[key]=[hash[key]]
+          hash[key] << val
+          dupe[key]=true
         end
       else
-        h[k]=v
+        hash[key]=val
       end
     }
-    return h
+    return hash
   end
 
 
@@ -64,8 +64,8 @@ module Enumerable
   #
   # ==Example
   #   strings = ["red","blue","green"]
-  #   strings.hash_by{|a| [a.size, a.titlecase]}
-  #   => {3 => "red", 4 => "blue", 5 => "green"}
+  #   strings.hash_by{|a| [a.size, a.upcase]}
+  #   => {3 => "RED", 4 => "BLUE", 5 => "GREEN"}
   #
   # Compare #index_by
 
@@ -249,16 +249,16 @@ module Enumerable
   # true, the second contains the elements for which block is false or nil.
 
   def bisect
-    a=[]
-    b=[]
-    each{|x| 
-     if yield(x)
-      a << x
+    accept=[]
+    reject=[]
+    each{|item| 
+     if yield(item)
+      accept << item
      else
-      b << x
+      reject << item
      end
     }
-    return a,b
+    return accept,reject
   end
 
 

data/lib/webget_ruby_ramp/string.rb

@@ -127,11 +127,11 @@ class String
  #   String.prev_char('0') => '9', true, true    # change & carry
  #   String.prev_char('-') => '-', false, false  # unchanged
 
- def self.prev_char(c) #=> prev_char, changed_flag, carry_flag
-  case c
+ def self.prev_char(chr) #=> prev_char, changed_flag, carry_flag
+  case chr
   when '1'..'9', 'B'..'Z', 'b'..'z'
-    i=(c.respond_to?(:ord) ? c.ord : c[0])
-    return (i-1).chr, true, false
+    pos=(chr.respond_to?(:ord) ? chr.ord : chr[0])
+    return (pos-1).chr, true, false
   when '0'
     return '9', true, true
   when 'A'
@@ -139,7 +139,7 @@ class String
   when 'a'
     return 'z', true, true
   else
-    return c, false, false
+    return chr, false, false
   end
  end
 

data/lib/webget_ruby_ramp/xml.rb

@@ -165,7 +165,7 @@ class REXML::Document
   # cf. Element#remove_attributes
 
   def remove_attributes
-    self.elements.each("//") { |e| e.attributes.each_attribute{|attribute| attribute.remove }}
+    self.elements.each("//") { |elem| elem.attributes.each_attribute{|attribute| attribute.remove }}
     self
   end
   

data/test/webget_ruby_ramp/array_test.rb

@@ -7,13 +7,16 @@ class ArrayTest < Test::Unit::TestCase
   def test_join
     a=['a','b','c']
     assert_equal('abc',a.join)
+    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('[',']'))
+    assert_raise(ArgumentError){ a.join('','','','') }
   end
 
   def test_size
     assert_equal(false,[].size?)
+    assert_equal(true,[nil].size?)
     assert_equal(true,[1].size?)
     assert_equal(true,[1,2].size?)
     assert_equal(true,[[]].size?)
@@ -25,56 +28,75 @@ class ArrayTest < Test::Unit::TestCase
    assert_equal([2,3,4,1],a)
    a.rotate!
    assert_equal([3,4,1,2],a)
+   a.rotate!
+   a=[]
+   a.rotate!
+   assert_equal([],a)
  end
 
  def test_choice
    a=[1,2,3,4]
-   c=a.choice
-   assert_equal(Fixnum,c.class)
-   assert(a.include?(c))
+   5.times {
+     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]))
+   5.times {
+     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))
+   assert_raise(ArgumentError){ foo.onto([]) }
  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))
+   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))
+   assert_equal([],[].slices(1))
+   assert_raise(ArgumentError){ a.slices(-1) }
+   assert_raise(ArgumentError){ a.slices("") }
+   assert_raise(ArgumentError){ a.slices(0.123) }
  end
 
- def test_divvy_evenly_divisible
+ def test_divvy
+   assert_equal([[1,2,3,4,5,6]],[1,2,3,4,5,6].divvy(1),'division into one slice')
    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')
+   assert_raise(ArgumentError){ [].divvy(-1) }
+   assert_raise(ArgumentError){ [].divvy("") }
+   assert_raise(ArgumentError){ [].divvy(0.123) }
  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)
+   a=[[1,2,3,4],[2,3,4,5],[3,4,5,6]]
+   assert_equal([1,2,3,4,5,6],a.union)
+   assert_equal([],[].union)
  end
 
  def test_intersect
-   a=[[2,3,4],[4,3,5],[3,4,7]]
+   a=[[1,2,3,4],[2,3,4,5],[3,4,5,6]]
    assert_equal([3,4],a.intersect)
+   assert_equal([],[].intersect)
  end
 
   def test_shifted
@@ -85,6 +107,9 @@ class ArrayTest < Test::Unit::TestCase
     assert_equal([        'c'],a.shifted(2))
     assert_equal([           ],a.shifted(3))
     assert_equal(nil          ,a.shifted(4))
+    assert_raise(ArgumentError){ a.shifted(-1) }
+    assert_raise(ArgumentError){ a.shifted("") }
+    assert_raise(ArgumentError){ a.shifted(0.123) }
   end
 
   # test_cdr must be idential to test_shifted
@@ -97,6 +122,9 @@ class ArrayTest < Test::Unit::TestCase
     assert_equal([        'c'],a.cdr(2))
     assert_equal([           ],a.cdr(3))
     assert_equal(nil          ,a.cdr(4))
+    assert_raise(ArgumentError){ a.cdr(-1) }
+    assert_raise(ArgumentError){ a.cdr("") }
+    assert_raise(ArgumentError){ a.cdr(0.123) }
   end
 
   # test_rest must be idential to test_shifted
@@ -109,6 +137,9 @@ class ArrayTest < Test::Unit::TestCase
     assert_equal([        'c'],a.rest(2))
     assert_equal([           ],a.rest(3))
     assert_equal(nil          ,a.rest(4))
+    assert_raise(ArgumentError){ a.rest(-1) }
+    assert_raise(ArgumentError){ a.rest("") }
+    assert_raise(ArgumentError){ a.rest(0.123) }
   end
 
   def test_shifted_bang
@@ -118,6 +149,10 @@ class ArrayTest < Test::Unit::TestCase
     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)
+    a=[]
+    assert_raise(ArgumentError){ a.shifted!(-1) }
+    assert_raise(ArgumentError){ a.shifted!("") }
+    assert_raise(ArgumentError){ a.shifted!(0.123) }
   end
 
   # alias: test_cdr_bang must be identical to test_shifted_bang
@@ -128,6 +163,10 @@ class ArrayTest < Test::Unit::TestCase
     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)
+    a=[]
+    assert_raise(ArgumentError){ a.cdr!(-1) }
+    assert_raise(ArgumentError){ a.cdr!("") }
+    assert_raise(ArgumentError){ a.cdr!(0.123) }
   end
 
   # alias: test_rest_band must be identical to test_shifted_bang
@@ -138,6 +177,10 @@ class ArrayTest < Test::Unit::TestCase
     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)
+    a=[]
+    assert_raise(ArgumentError){ a.rest!(-1) }
+    assert_raise(ArgumentError){ a.rest!("") }
+    assert_raise(ArgumentError){ a.rest!(0.123) }
   end
 
   def test_car
@@ -145,9 +188,29 @@ class ArrayTest < Test::Unit::TestCase
     assert_equal('a',a.car)
   end
 
+  def test_shuffle
+    a=[1,2,3,4]
+    5.times {
+      b=a.shuffle
+      assert_equal(a.size,b.size)
+      a.each{|item| assert(b.include?(item)) }
+    }
+  end
+
+  def test_shuffle_bang
+    a=[1,2,3,4]
+    b=a.dup
+    5.times {
+      b.shuffle!
+      assert_equal(a.size,b.size)
+      a.each{|item| assert(b.include?(item)) }
+    }
+  end
+
   def test_to_csv_one_dimensional
     a=["a","b","c"]
     assert_equal("a,b,c\n",a.to_csv)
+    assert_equal("",[].to_csv)    
   end
 
   def test_to_csv_multi_dimensional
@@ -158,12 +221,14 @@ class ArrayTest < Test::Unit::TestCase
   def test_to_tsv
     a=[["a", "b"], ["c", "d"], ["e", "f"]]
     assert_equal("a\tb\nc\td\ne\tf\n",a.to_tsv)
+    assert_equal("",[].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)
+    assert_equal("",[].to_tdf)    
   end
 
 end

data/test/webget_ruby_ramp/enumerable_test.rb

@@ -31,7 +31,7 @@ class EnumerableTest < Test::Unit::TestCase
   end
 
   def test_hash_by
-    assert_equal({3=>"Red",4=>"Blue",5=>"Green"},RGB.hash_by{|x| [x.size,x.titlecase]})
+    assert_equal({3=>"RED",4=>"BLUE",5=>"GREEN"},RGB.hash_by{|x| [x.size,x.upcase]})
   end
 
     

data/test/webget_ruby_ramp/yaml_test.rb

@@ -15,15 +15,15 @@ class YAMLTest < Test::Unit::TestCase
  def test_load_dir
   dirpath=File.join(MYDIR,'yaml_test_*.yml')
   expect=[
-   "a:a1,a10,a2,a20,a3,a30b:b1,b10,b2,b20,b3,b30c:c1,c10,c2,c20,c3,c30", 
-   "d:d1,d10,d2,d20,d3,d30e:e1,e10,e2,e20,e3,e30f:f1,f10,f2,f20,f3,f30", 
-   "g:g1,g10,g2,g20,g3,g30h:h1,h10,h2,h20,h3,h30i:i1,i10,i2,i20,i3,i30",
-   "j:j1,j10,j2,j20,j3,j30k:k1,k10,k2,k20,k3,k30l:l1,l10,l2,l20,l3,l30",
-   "m:m1,m10,m2,m20,m3,m30n:n1,n10,n2,n20,n3,n30o:o1,o10,o2,o20,o3,o30", 
-   "p:p1,p10,p2,p20,p3,p30q:q1,q10,q2,q20,q3,q30r:r1,r10,r2,r20,r3,r30", 
+   "a:a1,a10,a2,a20,a3,a30;b:b1,b10,b2,b20,b3,b30;c:c1,c10,c2,c20,c3,c30", 
+   "d:d1,d10,d2,d20,d3,d30;e:e1,e10,e2,e20,e3,e30;f:f1,f10,f2,f20,f3,f30", 
+   "g:g1,g10,g2,g20,g3,g30;h:h1,h10,h2,h20,h3,h30;i:i1,i10,i2,i20,i3,i30",
+   "j:j1,j10,j2,j20,j3,j30;k:k1,k10,k2,k20,k3,k30;l:l1,l10,l2,l20,l3,l30",
+   "m:m1,m10,m2,m20,m3,m30;n:n1,n10,n2,n20,n3,n30;o:o1,o10,o2,o20,o3,o30", 
+   "p:p1,p10,p2,p20,p3,p30;q:q1,q10,q2,q20,q3,q30;r:r1,r10,r2,r20,r3,r30", 
   ]
   actual=[]
-  YAML.load_dir(dirpath){|doc| actual << doc.keys.map{|k| v=doc[k]; "#{k}:#{v.sort.join(",")}" }.join("") }
+  YAML.load_dir(dirpath){|doc| actual << doc.keys.map{|k| v=doc[k]; "#{k}:#{v.sort.join(",")}" }.sort.join(";") }
   actual.sort!
   assert_equal(expect,actual,'YAML.load_dir')
  end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: webget_ruby_ramp
 version: !ruby/object:Gem::Version 
-  version: 1.7.2
+  version: 1.7.3
 platform: ruby
 authors: 
 - WebGet
@@ -32,7 +32,7 @@ cert_chain:
   DXnLFY0cVuBnNDMOOFl8vk1qIcZjcTovhzgcixpG6Uk5qmUsKHRLQf4oQJx7TfLK
   -----END CERTIFICATE-----
 
-date: 2010-02-16 00:00:00 -08:00
+date: 2010-02-17 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -46,9 +46,6 @@ extra_rdoc_files: []
 
 files: 
 - lib/webget_ruby_ramp.rb
-- lib/webget_ruby_ramp/active_record.rb
-- lib/webget_ruby_ramp/active_record/connection_adapters/abstract/schema_statements.rb
-- lib/webget_ruby_ramp/active_record/save_extensions.rb
 - lib/webget_ruby_ramp/array.rb
 - lib/webget_ruby_ramp/csv.rb
 - lib/webget_ruby_ramp/date.rb
@@ -104,9 +101,6 @@ signing_key:
 specification_version: 3
 summary: "WebGet Ruby Gem: Ramp gem provides base extensions to ruby classes and rails classes."
 test_files: 
-- test/webget_ruby_ramp/active_record_test.rb
-- test/webget_ruby_ramp/active_record/connection_adapters/abstract/schema_statements_test.rb
-- test/webget_ruby_ramp/active_record/save_extensions_test.rb
 - test/webget_ruby_ramp/array_test.rb
 - test/webget_ruby_ramp/csv_test.rb
 - test/webget_ruby_ramp/date_test.rb

metadata.gz.sig

@@ -1 +1 @@
-,�Xk��ai���a\�tbH�=� �{�_�*O���f8�.���,&�m��?]��9��=�]���<cӨS���a ��[��p��^"�$y�����`�Ű��{�|�3�����N�BB��=�
+���z(��
�1����_9�oDE%*H�TZ��M��f�
I��GK�.*�?_���@����_t��G���!�6�g����	�0H8�ț��I�6��ڢ�y`��߮�
��Bi���d�2)s!�|��/2

data/lib/webget_ruby_ramp/active_record.rb

@@ -1,119 +0,0 @@
-require 'activerecord'
-require 'active_record'
-
-#:startdoc:
-# ActiveRecord extensions
-
-module ActiveRecord #:doc:
-
-class Base #:doc:
-
-  # Create a record, or update a record if value passed matches a field in the AR object;
-  # includes method_missing function to make code more readable
-  #
-  # Most common use will be for testing (fixture/mock object generation)
-  #
-  # Three versions of method included:
-  # create_or_update
-  # create_or_update_by
-  # create_or_update_by_xxx (where xxx is a field name)
-  #
-  # Inspired by http://www.intridea.com/2008/2/19/activerecord-base-create_or_update-on-steroids-2
-  #
-  # ==Example
-  # { "admin"     => ["Administrator", 1000], 
-  #   "member"    => ["Member", 1], 
-  #   "moderator" => ["Moderator", 100],
-  #   "disabled"  => ["Disabled User", -1] }.each_pair do |key, val|
-  #     Role.create_or_update_by_key(:key => key, :name => val[0], :value => val[1])
-  # end
-
-  def self.create_or_update(options = {})
-    self.create_or_update_by(:id, options)
-  end
-
-
-  # Create or update a record by field (or fields).
-  # This will look for each field name as a key in the options hash.
-  #
-  # ==Example
-  #   attributes={:name="John Smith", :email=>"john@example.com", :birthdate=>'1980/01/01'}
-  #   User.create_or_update_by(:email,attributes)
-  #   => if a user with that email exists then update his name and birthdate, else create him
-  #
-  # ==Example with multiple conditions
-  #   attributes={:name="John Smith", :email=>"john@example.com", :birthdate=>'1980/01/01'}
-  #   User.create_or_update_by([:name,:birthdate],attributes)
-  #   => if a user with that name and birthdate exists then update his email, else create him
-  #
-  # The fields can be any mix of symbols or strings.
-  # The option keys can be any mix of symbols or strings.
-
-  def self.create_or_update_by(condition_keys, attribute_pairs = {})
-    condition_pairs=[*condition_keys].map{|key| [key,(attribute_pairs.delete(key)||attribute_pairs.delete(key.to_s)||attribute_pairs.delete(key.to_sym))]}.to_h
-    record = find(:first, :conditions => condition_pairs) || self.new
-    if record.new_record? then attribute_pairs.merge!(condition_pairs) end
-    attribute_pairs.each_pair{|key,val| record.send key.to_s+'=', val}
-    record.save!
-    return record
-  end
-
-
-  # Set up a database with initial data, e.g. in rake db:seed method.
-  #
-  # This will look for each field name as a key in the options hash.
-  #
-  # This method calls #create_or_update_by (and you may want to change
-  # this behavior to do more, e.g. to test that a DB and table exists).
-  #
-  # ==Example
-  #   attributes={:name="John Smith", :email=>"john@example.com", :birthdate=>'1980/01/01'}
-  #   User.create_or_update_by(:email,attributes)
-  #   => if a user with that email exists then update his name and birthdate, else create him
-  #
-  # ==Example with multiple conditions
-  #   attributes={:name="John Smith", :email=>"john@example.com", :birthdate=>'1980/01/01'}
-  #   User.create_or_update_by([:name,:birthdate],attributes)
-  #   => if a user with that name and birthdate exists then update his email, else create him
-  #
-  # The fields can be any mix of symbols or strings.
-  # The option keys can be any mix of symbols or strings.
-
-  def self.seed(condition_keys, attribute_pairs = {})
-    self.create_or_update_by(condition_keys, attribute_pairs)
-  end
-
-
-  # Method missing for create_or_update_by_xxx that forwards to #create_or_update_by
-  #
-  # ==Example
-  #   MyModel.create_or_update_by_foo(options)
-  #   => MyModel.create_or_update_by(:foo,option)
-
-  def self.method_missing_with_create_or_update(method_name, *args) 
-    if match = method_name.to_s.match(/create_or_update_by_([a-z0-9_]+)/)  
-      field = match[1]
-      return create_or_update_by(field,*args)
-    end
-    return method_missing_without_create_or_update(method_name, *args)
-  end
-
-
-  # For alias method chain
-  def self.included(base)
-    # base == ActiveRecord::Base (the class)
-    base.class_eval do
-        # class_eval makes self == ActiveRecord::Base, and makes def define instance methods.
-        extend ClassMethods
-        # If has_many were an instance method, we could do this
-        #   alias_method_chain :has_many, :association_option; end            
-        # but it's a class method, so we have to do the alias_method_chain on  
-        # the meta-class for ActiveRecord::Base, which is what class << self does.   
-        class << self;  alias_method_chain :method_missing, :create_or_update;  end
-      end
-  end
-
-
-end
-
-end

data/lib/webget_ruby_ramp/active_record/connection_adapters/abstract/schema_statements.rb

@@ -1,24 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters 
-    module SchemaStatements
-
-      # Add a column and its index.
-      # This just calls #add_column then #add_index
-
-      def add_column_and_index(table_name, column_name, type, options = {})
-        add_column(table_name, column_name, type, options)
-        add_index(table_name, column_name, type, options)
-      end
-
-
-      # Remove a column and its index in one step.
-      # This just calls #remove_column then #remove_index.
-
-      def remove_column_and_index(table_name, column_name, type, options = {})
-        remove_column(table_name, column_name, type, options)
-        remove_index(table_name, column_name, type, options)
-      end
-
-    end
-  end
-end

data/lib/webget_ruby_ramp/active_record/save_extensions.rb

@@ -1,35 +0,0 @@
-module ActiveRecord::SaveExtensions
-
-  # Save the record without validation, then reload it.
-  # If the record is valid then return true, otherwise raise RecordInvalid.
-  # This solves an issue we found with Rails associations not saving.
-  #
-  # By Andrew Carpenter (acarpen@wested.org)
-  #
-  # Deprecated, superceded by #save_redux!
-
-  def save_false_then_reload!
-    transaction do
-      save(false)
-      reload
-      valid? or raise ActiveRecord::RecordInvalid.new(self)
-    end
-    return true
-  end
-
-
-  # Save the record without validation, then reload, then save with validtion.
-  # This ensure that rails brings back the correct associations to validate.
-  # This solves an issue we found with Rails associations not saving.
-
-  def save_redux!
-    transaction do
-      save(false)
-      reload
-      save!
-    end
-    return true
-  end
-
-end
-ActiveRecord::Base.send(:include, ActiveRecord::SaveExtensions)

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

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

data/test/webget_ruby_ramp/active_record/save_extensions_test.rb

@@ -1,7 +0,0 @@
-require 'test/unit'
-require 'webget_ruby_ramp'
-require 'active_record'
-
-class SaveExtensionsText < Test::Unit::TestCase
-end
-

data/test/webget_ruby_ramp/active_record_test.rb

@@ -1,64 +0,0 @@
-require 'test/unit'
-require 'webget_ruby_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