quality_extensions 1.1.6 → 1.3.0

data/lib/quality_extensions/enumerable/grepv.rb

@@ -0,0 +1 @@
+str.lines.grepv(/#/) # all lines *not* beginnnig with #

data/lib/quality_extensions/enumerable/map_with_index.rb

@@ -4,6 +4,8 @@
 # License::   Ruby License
 # Submit to Facets?:: Yes. facets/enumerable/collect.rb only has non-in-place version (map_with_index).
 # Developer notes::
+# * No longer needed in Ruby 1.9.1:
+#   a.to_enum(:map!).with_index
 # Changes::
 #++
 

data/lib/quality_extensions/enumerable/max_by_value.rb

@@ -0,0 +1,72 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2010, Tyler Rick
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+# History::
+#++
+
+
+module Enumerable
+
+  # Instead of returns the object in enum that gives the maximum value from the
+  # given block, like max_by does, returns the *maximum value* calculated by
+  # the given block (which is tested on each object in enum, just like in
+  # max_by).
+  #
+  # Notice the difference:
+  #   ['a','abc','ab'].max_by       {|el| el.length}.should == 'abc'
+  #   ['a','abc','ab'].max_by_value {|el| el.length}.should == 3
+  #
+  def max_by_value(&block)
+    max_value = nil
+    each do |el|
+      value = yield el
+      if max_value.nil?
+        max_value = value
+      else
+        max_value = [value, max_value].max
+      end
+    end
+    max_value
+  end
+end
+
+
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec/autorun'
+
+describe 'Enumerable#max_by_value' do
+  it 'works in simple case' do
+    [1,3,2].max_by_value {|el| el}.should == 3
+  end
+
+  it 'works for array of strings' do
+    ['a','abc','ab'].max_by_value {|el| el.length}.should == 3
+    ['a','abc','ab'].max_by       {|el| el.length}.should == 'abc'
+  end
+
+  it 'works in more complicated example' do
+    files = [
+              ["app/controllers/application_controller.rb.orig",
+              Pathname.new('app/controllers/application_controller.rb')]
+            ]
+    max = files.max_by {|a| a.first.to_s.length}.first.to_s.length
+          files.max_by_value {|a| a.first.to_s.length}.should == max
+
+  end
+end
+=end
+

data/lib/quality_extensions/enumerable/select_while.rb

@@ -9,8 +9,8 @@
 # * !! Why does Hash#each_with_index yield |(k,v), i| but my select_with_index yields flat |k, v, i| ?
 #++
 
-require 'facets/kernel/require_local'
-require_local 'select_with_index'
+require 'facets/kernel/require_relative'
+require_relative 'select_with_index'
 
 module Enumerable
   # Original version before I changed it to use select so that Hash#select_until would return a hash instead of an array.
@@ -43,12 +43,17 @@ module Enumerable
   # If +inclusive+ is false, only those elements occuring _before_ the first element for which +block+ is true will be returned.
   # If +inclusive+ is true (the default), those elements occuring up to and _including_ the first element for which +block+ is true will be returned.
   #
+  # Examples:
+  #
   # (0..3).select_until        {|v| v == 1} # => [0, 1]
   # (0..3).select_until(false) {|v| v == 1} # => [0]
   #
   # {'a'=>1, 'b'=>2, 'c'=>3, 'd'=>1}.select_until        {|k, v| v == 2} ) # => {"a"=>1, "b"=>2}
   # {'a'=>1, 'b'=>2, 'c'=>3, 'd'=>1}.select_until(false) {|k, v| v == 2} ) # => {"a"=>1}
   #
+  # puts caller # => 30 lines of context, many of them so far removed that they are irrelevant
+  # puts caller.select_until {|l| l =~ %r(/app/) } # only print the stack back to the first frame from our own code
+  #
   def select_until(inclusive = true)
     return self unless block_given?
 

data/lib/quality_extensions/enumerable/select_with_index.rb

@@ -8,8 +8,8 @@
 # History::
 #++
 
-require 'facets/kernel/require_local'
-require_local 'select_bang'
+require 'facets/kernel/require_relative'
+require_relative 'select_bang'
 
 module Enumerable
 #   def reject!

data/lib/quality_extensions/float/truncate.rb

@@ -32,11 +32,12 @@ require 'quality_extensions/module/alias_method_chain'
 # end
 
 class Float
+  # This is the same as round_at except instead of rounding (up or down) to the nearest integer, it always truncates, rounding down to the next lowest integer.
   def truncate_with_precision(d)
    (self * (10.0 ** d)).truncate_without_precision.to_f / (10.0 ** d)
   end
   alias_method_chain :truncate, :precision
-end 
+end
 
 
 #  _____         _

data/lib/quality_extensions/hash/except.rb

@@ -1,3 +1,3 @@
 # Alias for:
-require 'facets/kernel/require_local'
-require_local 'only'
+require 'facets/kernel/require_relative'
+require_relative 'only'

data/lib/quality_extensions/hash/to_query_string.rb

@@ -8,8 +8,8 @@
 $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
 autoload :CGI, 'cgi'
 require 'rubygems'
-require 'facets/kernel/require_local'
-require_local '../array/to_query_string.rb'
+require 'facets/kernel/require_relative'
+require_relative '../array/to_query_string.rb'
 
 class Hash
 
@@ -86,7 +86,7 @@ class TheTest < Test::Unit::TestCase
         }
       }
     }
-    assert_equal ['foo=bar', 'names[common]=smith', 'names[uncommon][first]=lance', 'names[uncommon][last]=wilheiminkauf'].to_set, 
+    assert_equal ['foo=bar', 'names[common]=smith', 'names[uncommon][first]=lance', 'names[uncommon][last]=wilheiminkauf'].to_set,
                   data.to_query_string.split(/&/).to_set
   end
   def test_hash_to_query_string_nesting_2
@@ -98,13 +98,13 @@ class TheTest < Test::Unit::TestCase
         ]
     }
     assert_equal 'names[common]=smith&names[uncommon][]=frankenwatzel&names[uncommon][]=wilheiminkauf', data.to_query_string('names')
-    assert_equal( {'names' => data}.to_query_string(), 
+    assert_equal( {'names' => data}.to_query_string(),
                   data.to_query_string('names') )
   end
-  
+
   def test_hash_to_query_string_encoding
     data = {'f&r' => 'a w$'}
-    
+
     assert_equal 'f%26r=a+w%24', data.to_query_string
   end
 end

data/lib/quality_extensions/helpers/numbers.rb

@@ -0,0 +1,259 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Ruby on Rails developers
+# License::   Ruby on Rails license
+# Submit to Facets?:: yes
+# Developer notes::
+# History::
+#++
+
+require 'facets/hash/symbolize_keys'
+
+
+class Array
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+end
+
+#-------------------------------------------------------------------------------
+
+module Kernel
+  # TODO: use quality_extensions/helpers/numbers instead
+  # Adapted from /var/lib/gems/1.9.1/gems/actionpack-2.3.4/lib/action_view/helpers/number_helper.rb
+
+  # Formats a +number+ with grouped thousands using +delimiter+ (e.g., 12,324). You can
+  # customize the format in the +options+ hash.
+  #
+  # ==== Options
+  # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to ",").
+  # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+  #
+  # ==== Examples
+  #  number_with_delimiter(12345678)                        # => 12,345,678
+  #  number_with_delimiter(12345678.05)                     # => 12,345,678.05
+  #  number_with_delimiter(12345678, :delimiter => ".")     # => 12.345.678
+  #  number_with_delimiter(12345678, :separator => ",")     # => 12,345,678
+  #  number_with_delimiter(98765432.98, :delimiter => " ", :separator => ",")
+  #  # => 98 765 432,98
+  #
+  # You can still use <tt>number_with_delimiter</tt> with the old API that accepts the
+  # +delimiter+ as its optional second and the +separator+ as its
+  # optional third parameter:
+  #  number_with_delimiter(12345678, " ")                     # => 12 345.678
+  #  number_with_delimiter(12345678.05, ".", ",")             # => 12.345.678,05
+  def number_with_delimiter(number, *args)
+    options = args.extract_options!
+    options.symbolize_keys!
+
+    unless args.empty?
+      ActiveSupport::Deprecation.warn('number_with_delimiter takes an option hash ' +
+        'instead of separate delimiter and precision arguments.', caller)
+      delimiter = args[0] || '.'
+      separator = args[1] || ','
+    end
+
+    delimiter ||= (options[:delimiter] || '.')
+    separator ||= (options[:separator] || ',')
+
+    begin
+      parts = number.to_s.split('.')
+      parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
+      parts.join(separator)
+    #rescue
+    #  number
+    end
+  end
+
+  # Formats a +number+ with the specified level of <tt>:precision</tt> (e.g., 112.32 has a precision of 2).
+  # You can customize the format in the +options+ hash.
+  #
+  # ==== Options
+  # * <tt>:precision</tt>  - Sets the level of precision (defaults to 3).
+  # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+  # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to "").
+  #
+  # ==== Examples
+  #  number_with_precision(111.2345)                    # => 111.235
+  #  number_with_precision(111.2345, :precision => 2)   # => 111.23
+  #  number_with_precision(13, :precision => 5)         # => 13.00000
+  #  number_with_precision(389.32314, :precision => 0)  # => 389
+  #  number_with_precision(1111.2345, :precision => 2, :separator => ',', :delimiter => '.')
+  #  # => 1.111,23
+  #
+  # You can still use <tt>number_with_precision</tt> with the old API that accepts the
+  # +precision+ as its optional second parameter:
+  #   number_with_precision(number_with_precision(111.2345, 2)   # => 111.23
+  def number_with_precision(number, *args)
+    options = args.extract_options!
+    options.symbolize_keys!
+
+    precision ||= (options[:precision] || 3)
+    separator ||= (options[:separator] || '.')
+    delimiter ||= (options[:delimiter] || '')
+
+    begin
+      rounded_number = (Float(number) * (10 ** precision)).round.to_f / 10 ** precision
+      number_with_delimiter("%01.#{precision}f" % rounded_number,
+        :separator => separator,
+        :delimiter => delimiter)
+    #rescue
+    #  number
+    end
+  end
+
+  # Formats the bytes in +size+ into a more understandable representation
+  # (e.g., giving it 1500 yields 1.5 KB). This method is useful for
+  # reporting file sizes to users. This method returns nil if
+  # +size+ cannot be converted into a number. You can customize the
+  # format in the +options+ hash.
+  #
+  # ==== Options
+  # * <tt>:base</tt>       - Pass in 2 (or 1024) to use binary units (KiB, MiB),
+  #                          pass in 10 (or 1000) to use SI (decimal) units (KB, MB)
+  #                          (defaults to base 10).
+  # * <tt>:precision</tt>  - Sets the level of precision (defaults to 1).
+  # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+  # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to "").
+  #
+  # ==== Examples
+  #  number_to_human_size(123)                                          # => 123 Bytes
+  #  number_to_human_size(1234)                                         # => 1.2 KB
+  #  number_to_human_size(12345)                                        # => 12.3 KB
+  #  number_to_human_size(1234567)                                      # => 1.2 MB
+  #  number_to_human_size(1234567890)                                   # => 1.2 GB
+  #  number_to_human_size(1234567890123)                                # => 1.2 TB
+  #  number_to_human_size(1234567, :precision => 2)                     # => 1.23 MB
+  #  number_to_human_size(1234567, :precision => 2, :base => 2)         # => 1.18 MiB
+  #  number_to_human_size(483989, :precision => 0)                      # => 484 KB
+  #  number_to_human_size(483989, :precision => 0, :base => 2)          # => 473 KiB
+  #  number_to_human_size(1234567, :precision => 2, :separator => ',')  # => 1,23 MB
+  #
+  # ==== Differences from ActiveSupport version
+  #  The ActiveSupport version defaults to binary (base 2) units, while this one
+  #  defaults to SI (base 10) units.
+  #
+  #  The ActiveSupport incorrectly uses KB to refer to binary units, when the correct
+  #  abbreviation would be KiB (see http://en.wikipedia.org/wiki/Binary_prefix).
+  #
+  #  This version has a :base option to let you change the base; the ActiveSupport
+  #  version does not.
+  #
+  def number_to_human_size(number, *args)
+    return nil if number.nil?
+
+    options = args.extract_options!
+    options.symbolize_keys!
+
+    precision ||= (options[:precision] || 1)
+    separator ||= (options[:separator] || '.')
+    delimiter ||= (options[:delimiter] || ',')
+    base      ||= (options[:base]      || 10)
+
+    # http://en.wikipedia.org/wiki/Binary_prefix
+    if base == 10 || base == 1000
+      storage_units = %w( Bytes KB MB GB TB ).freeze
+      base = 1000
+    elsif base == 2 || base == 1024
+      storage_units = %w( Bytes KiB MiB GiB TiB ).freeze
+      base = 1024
+    else
+      raise ArgumentError, "base must be 1000 or 1024"
+    end
+    storage_units_format = '%n %u'
+
+    if number.to_i < base
+      unit = number.to_i == 1 ? 'byte' : 'bytes'
+      storage_units_format.gsub(/%n/, number.to_i.to_s).gsub(/%u/, unit)
+    else
+      max_exp  = storage_units.size - 1
+      number   = Float(number)
+      exponent = (Math.log(number) / Math.log(base)).to_i # Convert to base 1024
+      exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
+      number  /= base ** exponent
+
+      unit = storage_units[exponent]
+
+      begin
+        escaped_separator = Regexp.escape(separator)
+        formatted_number = number_with_precision(number,
+          :precision => precision,
+          :separator => separator,
+          :delimiter => delimiter
+        ).sub(/(\d)(#{escaped_separator}[1-9]*)?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
+        storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit)
+      #rescue
+      #  number
+      end
+    end
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'spec/autorun'
+
+describe 'number_to_human_size' do
+  it 'uses decimal unit (KB) when using base 1000' do
+    number_to_human_size(524288, :base => 1000).should match(/ KB$/)
+  end
+
+  it 'uses the correct conversion when using base 1000' do
+    number_to_human_size(524288, :base => 1000).should match(/^524\.3 /)
+  end
+
+  it 'uses binary unit (KiB) when using base 1024' do
+    number_to_human_size(524288, :base => 1024).should match(/ KiB$/)
+  end
+
+  it 'uses the correct conversion when using base 1024' do
+    number_to_human_size(524288, :base => 1024).should match(/^512 /)
+  end
+end
+
+describe 'number_to_human_size examples' do
+  it '1234' do
+    number_to_human_size(123).should == '123 bytes'
+  end
+
+  it '12345' do
+    number_to_human_size(12345).should == '12.3 KB'
+  end
+
+  it '1234567' do
+    number_to_human_size(1234567).should == '1.2 MB'
+    number_to_human_size(1234567, :base => 2).should == '1.2 MiB'
+  end
+
+  it '1234567890' do
+    number_to_human_size(1234567890).should == '1.2 GB'
+  end
+
+  it '1234567890123' do
+    number_to_human_size(1234567890123).should == '1.2 TB'
+  end
+
+  it '1234567' do
+    number_to_human_size(1234567, :precision => 2).should == '1.23 MB'
+    number_to_human_size(1234567, :precision => 2, :base => 2).should == '1.18 MiB'
+  end
+
+  it '483989' do
+    number_to_human_size(483989, :precision => 0).should == '484 KB'
+    number_to_human_size(483989, :precision => 0, :base => 2).should == '473 KiB'
+  end
+
+  it '1234567' do
+    number_to_human_size(1234567, :precision => 2, :separator => ',').should == '1,23 MB'
+  end
+end
+
+
+=end
+

data/lib/quality_extensions/kernel/die.rb

@@ -25,8 +25,8 @@ $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
 require 'test/unit'
 require 'rubygems'
 require 'quality_extensions/kernel/capture_output'
-#require 'facets/kernel/require_local'
-#require_local './capture_output'
+#require 'facets/kernel/require_relative'
+#require_relative './capture_output'
 
 class TheTest < Test::Unit::TestCase