sixarm_ruby_ramp 2.1.3 → 3.0.0

data/lib/sixarm_ruby_ramp/numeric.rb

@@ -5,40 +5,54 @@
 class Numeric
 
 
- # @return 0 if the given flag is any of: nil, false, 0, [], {}
- #
- # @example
- #   3.if(true) => 3
- #   3.if(false) => 0
- #   
-
- def if(flag)
-   if [nil,false,0,[],{}].include?(flag) then 0 else self end
- end
-
-
- # @return self if flag is nil, false, 0, [], {}; otherwise return 0.
- #
- # @example
- #   3.unless(true) => 0
- #   3.unless(false) => 3
-
- def unless(flag)
-   if [nil,false,0,[],{}].include?(flag) then self else 0 end
- end
-
-
- # @return self as a percent, i.e. * 100 then call round.
- #
- # @example
- #   x = 0.12345
- #   x.percent => 12
- #   x.percent(1) => 12.3
- #   x.percent(2) => 12.34
- #   x.percent(-1) => 10
-
- def percent(ndigits=0)
-  (self * 100).round(ndigits)
- end
+  # @return 0 if the given flag is any of: nil, false, 0, [], {}
+  #
+  # @example
+  #   3.if(true) => 3
+  #   3.if(false) => 0
+  #
+  def if(flag)
+    if [nil,false,0,[],{}].include?(flag) then 0 else self end
+  end
+
+
+  # @return self if flag is nil, false, 0, [], {}; otherwise return 0.
+  #
+  # @example
+  #   3.unless(true) => 0
+  #   3.unless(false) => 3
+  #
+  def unless(flag)
+    if [nil,false,0,[],{}].include?(flag) then self else 0 end
+  end
+
+
+  # @return self as a percent, i.e. * 100 then call round.
+  #
+  # @example
+  #   x = 0.12345
+  #   x.percent => 12
+  #   x.percent(1) => 12.3
+  #   x.percent(2) => 12.34
+  #   x.percent(-1) => 10
+  #
+  def percent(ndigits=0)
+    (self * 100).round(ndigits)
+  end
+
+
+  # @return self, truncated to a given precision
+  #
+  # @example
+  #   x = 0.12345
+  #   x.floor_precision(0) => 0.0
+  #   x.floor_precision(1) => 0.1
+  #   x.floor_precision(2) => 0.12
+  #   x.floor_precision(3) => 0.123
+  #
+  def floor_precision(precision)
+    return self if is_a?(Float) && nan?
+    (self * (10 ** precision)).truncate.fdiv(10 ** precision)
+  end
 
 end

data/lib/sixarm_ruby_ramp/process.rb

@@ -47,29 +47,14 @@ module Process
   # -
   # OPTIMIZE: add dates, times
 
+  PS_TO_I = %w(c egid egroup uid fgid lwp ni nlwp pgid pid ppid rgid rss ruid sid sgid suid)
+  PS_TO_F = %w(cp pcpu pmem)
+
   def self.pss(pid=Process.pid)
     ps=self.ps(pid)
     h=Hash[*self.ps_keys.zip(ps.split).flatten]
-    h['c']      =h['c'].to_i
-    h['cp']     =h['cp'].to_f
-    h['egid']   =h['egid'].to_i
-    h['egroup'] =h['egroup'].to_i
-    h['uid']    =h['uid'].to_i
-    h['fgid']   =h['fgid'].to_i
-    h['lwp']    =h['lwp'].to_i
-    h['ni']     =h['ni'].to_i
-    h['nlwp']   =h['nlwp'].to_i
-    h['pcpu']   =h['pcpu'].to_f
-    h['pgid']   =h['pgid'].to_i
-    h['pid']    =h['pid'].to_i
-    h['pmem']   =h['pmem'].to_f
-    h['ppid']   =h['ppid'].to_i
-    h['rgid']   =h['rgid'].to_i
-    h['rss']    =h['rss'].to_i
-    h['ruid']   =h['ruid'].to_i  
-    h['sid']    =h['sid'].to_i  
-    h['sgid']   =h['sgid'].to_i  
-    h['suid']   =h['suid'].to_i  
+    PS_TO_I.each{|x| h[x]=h[x].to_i}
+    PS_TO_F.each{|x| h[x]=h[x].to_f}
     self.ps_aliases.each_pair{|key,val| h[key]=h[val]}
     return h
   end

data/lib/sixarm_ruby_ramp/string.rb

@@ -111,7 +111,7 @@ class String
  # @see String#increment
 
  def decrement(step=1)
-  self=~/\d+/ ? $`+($&.to_i-step).to_s+$' : self
+  increment(-step)
  end
 
 
@@ -188,9 +188,8 @@ class String
 
  # Helpful constants
 
- LOWERCASE_ENGLISH_CHARS = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
- UPPERCASE_ENGLISH_CHARS = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
-
+ LOWERCASE_ENGLISH_CHARS = ('a'..'z').to_a
+ UPPERCASE_ENGLISH_CHARS = ('A'..'Z').to_a
 
  ##
  #

data/lib/sixarm_ruby_ramp/xml.rb

@@ -1,204 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'rexml/document' 
-
-# XML extensions
-
-module XML
-
-
-  # Specify one or more directory patterns and pass each XML 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 To load xml documents
-  #   XML.load_dir('/tmp/*.xml'){|xml_document|
-  #     #...whatever you want to do with each xml document
-  #   }
-  #
-  # @example To load xml documents in files beginning in "foo" or "bar"
-  #   XML.load_dir('/tmp/foo*.yaml','/tmp/bar*.xml','){|xml_document|
-  #     #...whatever you want to do with the xml document
-  #   }
-
-  def XML.load_dir(*dirpaths)
-    dirpaths=[*dirpaths.flatten]
-    dirpaths.each do |dirpath|
-      Dir[dirpath].sort.each do |filename|
-        File.open(filename) do |file|
-          doc = REXML::Document.new file
-          yield doc
-        end #file
-      end #dir
-    end #each
-  end #def                                                                                                                                                                                                                          
-
-
-  # Sugar to load elements from a file.
-  #
-  # @example
-  #   XML.load_attributes('config.xml','userlist/user'){|element| pp element.attributes['first_name'] }
-
-  def XML.load_elements(dirpath,xpath)
-    XML.load_dir(dirpath){|doc|
-      doc.elements.each(xpath){|elem|
-        yield elem
-      }
-    }
-  end
-
-
-  # Sugar to load attributes from a file.
-  #
-  # @example
-  #   XML.load_attributes('config.xml','userlist/user'){|attributes| pp attributes['first_name'] }
-
-  def XML.load_attributes(dirpath,xpath)
-    XML.load_elements(dirpath,xpath){|elem|
-      yield elem.attributes
-    }
-  end
-
-  # Sugar to load attributes hash from a file.
-  #
-  # @example
-  #   XML.load_attributes('config.xml','userlist/user'){|attributes| pp attributes['first_name'] }
-
-  def XML.load_attributes_hash(dirpath,xpath)
-    XML.load_elements(dirpath,xpath){|elem|
-      yield elem.attributes.to_hash
-    }
-  end
-
-
-  # Santize dirty xml by removing unprintables, bad tags,
-  # comments, and generally anything else we might need
-  # to enable the XML parser to handle a dirty document.
-  #
-  # This method calls these in order:
-  #   - XML.strip_unprintables
-  #   - XML.strip_microsoft
-  #   - XML.strip_comments
-  #   - XML.strip_attributes
-  #
-  # @example 
-  #   # This example shows curly braces instead of angle braces because of HTML formatting
-  #   s="{foo a=b c=d}{!--comment--}Hello{!-[if bar]}Microsoft{![endif]}World{/foo}"
-  #   XML.strip_all(s) => "{foo}HelloWorld{/foo}"
-  #
-  # @return [String] the text, stripped of unprintables, Microsoft markup, comments, and attributes
-
-  def XML.strip_all(xml_text)
-    return XML.strip_attributes(XML.strip_comments(XML.strip_microsoft(XML.strip_unprintables(xml_text))))
-  end
-
-
-  # Strip out all attributes from the xml text's tags.
-  #
-  # @example
-  #   s="<foo a=b c=d e=f>Hello</foo>"
-  #   XML.strip_attributes(s) => "<foo>Hello</foo>"
-  #
-  # @return [String] the text, stripped of attributes
-
-  def XML.strip_attributes(xml_text)
-    return xml_text.gsub(/<(\/?\w+).*?>/im){"<#{$1}>"}  # delete attributes
-  end
-
-
-  # Strip out all comments from the xml text.
-  #
-  # @example
-  #   # This example shows curly braces instead of angle braces because of HTML formatting
-  #   s="Hello{!--comment--}World"
-  #   XML.strip_comments(s) => "HelloWorld"
-  #
-  # @return [String] the text, stripped of comments
-
-  def XML.strip_comments(xml_text)
-    return xml_text.gsub(/<!.*?>/im,'')  
-  end
-
-
-  # Strip out all microsoft proprietary codes.
-  #
-  # @example
-  #   s="Hello<!-[if foo]>Microsoft<![endif]->World"
-  #   XML.strip_microsoft(s) => "HelloWorld"
-  #
-  # @return [String] the text, stripped of Microsoft markup
-
-  def XML.strip_microsoft(xml_text)
-    return xml_text.gsub(/<!-*\[if\b.*?<!\[endif\]-*>/im,'')
-  end
-
-
-  # Strip out all unprintable characters from the input string.
-  #
-  # @example
-  #   s="Hello\XXXWorld" # where XXX is unprintable
-  #   XML.strip_unprintables(s) => "HelloWorld"
-  #
-  # @return [String] the text, stripped of unprintables
-
-  def XML.strip_unprintables(xml_text)
-    return xml_text.gsub(/[^[:print:]]/, "")
-  end
-
-end
-
-
-# REXML::Attributes extensions
-
-class REXML::Attributes
-
-  # @return a new hash of the attribute keys and values.
-  #
-  # @example
-  #   attributes.to_hash => {"src"=>"pic.jpg", "height" => "100", "width" => "200"} 
-
-  def to_hash
-    h=Hash.new
-    self.keys.each{|k| h[k]=self[k]}
-    h
-  end
-
-end
-
-
-# REXML::Document extensions
-
-class REXML::Document
-
-  # Remove all attributes from the document's elements.
-  # 
-  # @return the document.
-  #
-  # @see Element#remove_attributes
-
-  def remove_attributes
-    self.elements.each("//") { |elem| elem.attributes.each_attribute{|attribute| attribute.remove }}
-    self
-  end
-  
-end
-
-
-# REXML::Element extensions
-
-class REXML::Element
-
-  # Remove all attributes from the element.
-  #
-  # @return the element.
-  #
-  # @see Document#remove_attributes
-
-  def remove_attributes
-    self.attributes.each_attribute{|attribute| attribute.remove }
-    self
-  end
-
-end
-
-
-

data/test/sixarm_ruby_ramp_test.rb

@@ -1,9 +1,9 @@
 # -*- coding: utf-8 -*-
-require 'test/unit'
+require 'minitest/autorun'
 require 'simplecov'
 SimpleCov.start
 
 ['array','class','csv','date','enumerable','file','fixnum','hash','integer','io','kernel','math','nil','numeric','object','process','string','symbol','time','xml','yaml'].map{|x|
-  require "sixarm_ruby_ramp/#{x}_test.rb"
+  require "sixarm_ruby_ramp_test/#{x}_test.rb"
 }
 

data/test/sixarm_ruby_ramp_test/array_test.rb

@@ -0,0 +1,330 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'csv'
+require 'sixarm_ruby_ramp'
+
+
+class ArrayTest < Minitest::Test
+
+  A=['a','b','c','d']
+  B=['w','x','y','z']
+
+  def test_join_with_no_ops
+    assert_equal('abcd',A.join())
+  end
+
+  def test_join_with_1_op_does_infix
+    assert_equal('a*b*c*d', A.join('*'))
+  end
+
+  def test_join_with_2_ops_does_prefix_suffix
+    assert_equal('[a][b][c][d]', A.join('[',']'))
+  end
+
+  def test_join_with_3_opes_does_prefix_suffix_infix
+    assert_equal('[a]*[b]*[c]*[d]', A.join('[',']','*'))
+  end
+
+  def test_join_with_too_many_ops_raises
+    assert_raises(ArgumentError){ A.join('','','','') }
+  end
+  
+  def test_join_prefix_suffix
+    assert_equal('[a][b][c][d]', A.join_prefix_suffix('[',']'))
+  end
+
+  def test_join_prefix_suffix_infix
+    assert_equal('[a]*[b]*[c]*[d]', A.join_prefix_suffix_infix('[',']','*'))
+  end
+
+  def test_size_with_one_item
+    assert_equal(true,[1].size?)
+  end
+
+  def test_size_with_two_items
+    assert_equal(true,[1,2].size?)
+  end
+
+  def test_size_with_empty
+    assert_equal(false,[].size?)
+  end
+
+  def test_size_with_nil
+    assert_equal(true,[nil].size?)
+  end
+
+  def test_size_with_one_empty
+    assert_equal(true,[[]].size?)
+  end
+  
+ def test_rotate
+   a=A.dup
+   a.rotate!
+   assert_equal(['b','c','d','a'],a)
+   a.rotate!
+   assert_equal(['c','d','a','b'],a)
+   a.rotate!
+   assert_equal(['d','a','b','c'],a)
+   a.rotate!
+   assert_equal(['a','b','c','d'],a)
+ end
+
+ def test_rotate_with_empty
+   a=[]
+   a.rotate!
+   assert_equal([],a)
+ end
+
+ def test_choice
+   5.times {
+     c=A.choice
+     assert_equal(String,c.class)
+     assert(A.include?(c))
+   }
+ end
+
+ def test_choices
+   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
+   assert_equal({'a'=>'w', 'b'=>'x', 'c'=>'y', 'd'=>'z'},A.onto(B))
+ end
+
+ def test_onto_with_empty
+   assert_raises(ArgumentError){ A.onto([]) }
+ end
+
+ def test_union
+   a=[[1,2,3,4],[2,3,4,5],[3,4,5,6]]
+   assert_equal([1,2,3,4,5,6],a.union)
+ end
+
+ def test_union_with_empty
+   assert_equal([],[].union)
+ end
+
+ def test_intersect
+   a=[[1,2,3,4],[2,3,4,5],[3,4,5,6]]
+   assert_equal([3,4],a.intersect)
+ end
+
+ def test_intersect_with_empty
+   assert_equal([],[].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
+
+  def test_shifted_with_negative_count
+    assert_raises(ArgumentError){ [].shifted(-1) }
+  end
+
+  def test_shifted_with_non_integer_count
+    assert_raises(ArgumentError){ [].shifted(0.123) }
+  end
+
+  def test_shifted_with_non_numeric_count
+    assert_raises(ArgumentError){ [].shifted("") }
+  end
+
+  # alias: test_cdr must be idential to test_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
+
+  # alias: test_cdr must be idential to test_shifted
+  def test_cdr_with_negative_count    
+    assert_raises(ArgumentError){ [].cdr(-1) }
+  end
+
+  # alias: test_cdr must be idential to test_shifted
+  def test_cdr_with_non_integer_count
+    assert_raises(ArgumentError){ [].cdr(0.123) }
+  end
+
+  # alias: test_cdr must be idential to test_shifted
+  def test_cdr_with_non_numeric_count
+    assert_raises(ArgumentError){ [].cdr("") }
+  end
+
+  # alias: test_rest must be idential to test_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
+
+  # alias: test_rest must be idential to test_shifted
+  def test_rest_with_negative_count
+    assert_raises(ArgumentError){ [].rest(-1) }
+  end
+
+  # alias: test_rest must be idential to test_shifted
+  def test_rest_with_non_integer_count
+    assert_raises(ArgumentError){ [].rest(0.123) }
+  end
+
+  # alias: test_rest must be idential to test_shifted
+  def test_rest_with_non_numeric_count
+    assert_raises(ArgumentError){ [].rest("") }
+  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
+
+  def test_shifted_bang_with_negative_count    
+    assert_raises(ArgumentError){ [].shifted!(-1) }
+  end
+
+  def test_shifted_bang_with_non_integer_count    
+    assert_raises(ArgumentError){ [].shifted!(0.123) }
+  end
+
+  def test_shifted_bang_with_non_numeric_count    
+    assert_raises(ArgumentError){ [].shifted!("") }
+  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_cdr_bang must be identical to test_shifted_bang
+  def test_cdr_bang_with_negative_count
+    assert_raises(ArgumentError){ [].cdr!(-1) }
+  end
+
+  # alias: test_cdr_bang must be identical to test_shifted_bang
+  def test_cdr_bang_with_non_integer_count
+    assert_raises(ArgumentError){ [].cdr!(0.123) }
+  end
+
+  # alias: test_cdr_bang must be identical to test_shifted_bang
+  def test_cdr_bang_with_non_numeric_count
+    assert_raises(ArgumentError){ [].cdr!("") }
+  end
+  
+  # alias: test_rest_bang 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
+    
+  # alias: test_rest_bang must be identical to test_shifted_bang
+  def test_rest_bang_with_negative_count
+    assert_raises(ArgumentError){ [].rest!(-1) }
+  end
+
+  # alias: test_rest_bang must be identical to test_shifted_bang
+  def test_rest_bang_with_non_integer_count
+    assert_raises(ArgumentError){ [].rest!(0.123) }
+  end
+
+  # alias: test_rest_bang must be identical to test_shifted_bang
+  def test_rest_bang_with_non_numeric_count
+    assert_raises(ArgumentError){ [].rest!("") }
+  end
+
+  def test_car
+    a=['a','b','c']
+    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
+    assert_equal("a,b,c,d\n",A.to_csv)
+  end
+
+  def test_to_csv_with_empty
+    assert_equal("",[].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
+
+  def test_to_tsv_with_empty
+    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)
+  end
+
+  # alias: test_to_tdf must be identical to test_to_tsv
+  def test_to_tdf_with_empty
+    assert_equal("",[].to_tdf)    
+  end
+
+end
+
+