(1..99).min #=> 1(1..99).max #=> 99(1..99).minmax #=> [1, 99]

In Ruby 2.4, Enumurable#min, Enumurable#maxmethods andEnumurable#minmax methodare now more optimized.

We would run the following benchmark snippet for both Ruby 2.3 and Ruby 2.4 andobserve the results

require 'benchmark/ips'Benchmark.ips do |bench|NUM1 = 1_000_000.times.map { rand }ENUM_MIN = Enumerable.instance_method(:min).bind(NUM1)ENUM_MAX = Enumerable.instance_method(:max).bind(NUM1)ENUM_MINMAX = Enumerable.instance_method(:minmax).bind(NUM1)bench.report('Enumerable#min') doENUM_MIN.callendbench.report('Enumerable#max') doENUM_MAX.callendbench.report('Enumerable#minmax') doENUM_MINMAX.callendend

Results for Ruby 2.3

Warming up --------------------------------------Enumerable#min 1.000 i/100msEnumerable#max 1.000 i/100msEnumerable#minmax 1.000 i/100msCalculating -------------------------------------Enumerable#min 14.810 (13.5%) i/s - 73.000 in 5.072666sEnumerable#max 16.131 ( 6.2%) i/s - 81.000 in 5.052324sEnumerable#minmax 11.758 ( 0.0%) i/s - 59.000 in 5.026007s

Ruby 2.4

Warming up --------------------------------------Enumerable#min 1.000 i/100msEnumerable#max 1.000 i/100msEnumerable#minmax 1.000 i/100msCalculating -------------------------------------Enumerable#min 18.091 ( 5.5%) i/s - 91.000 in 5.042064sEnumerable#max 17.539 ( 5.7%) i/s - 88.000 in 5.030514sEnumerable#minmax 13.086 ( 7.6%) i/s - 66.000 in 5.052537s

From the above benchmark results, it can be seen that there has been animprovement in the run times for the methods.

Internally Ruby has changed the logic by which objects are compared, whichresults in these methods being optimized. You can have a look at the commitshere andhere.

Ruby 2.3

CSV::Row.new(%w(banana mango), [1,2]).each #=> #<CSV::Row "banana":1 "mango":2>CSV::Row.new(%w(banana mango), [1,2]).delete_if #=> #<CSV::Row "banana":1 "mango":2>

Some methods raise exception because of this behavior.

> ruby -rcsv -e 'CSV::Table.new([CSV::Row.new(%w{banana mango}, [1, 2])]).by_col.each' #=> /Users/sushant/.rbenv/versions/2.3.0/lib/ruby/2.3.0/csv.rb:850:in `block in each': undefined method `[]' for nil:NilClass (NoMethodError)  from /Users/sushant/.rbenv/versions/2.3.0/lib/ruby/2.3.0/csv.rb:850:in `each'  from /Users/sushant/.rbenv/versions/2.3.0/lib/ruby/2.3.0/csv.rb:850:in `each'  from -e:1:in `<main>'

Ruby 2.4fixed this issue.

Ruby 2.4

CSV::Row.new(%w(banana mango), [1,2]).each #=> #<Enumerator: #<CSV::Row "banana":1 "mango":2>:each>CSV::Row.new(%w(banana mango), [1,2]).delete_if #=> #<Enumerator: #<CSV::Row "banana":1 "mango":2>:delete_if>

As we can see, these methods now return an enumerator when no block is given.

In Ruby 2.4 following code will not raise any exception.

> ruby -rcsv -e 'CSV::Table.new([CSV::Row.new(%w{banana mango}, [1, 2])]).by_col.each'

In Ruby 2.3, these methods convert time into system timezone offset instead ofpreserving timezone offset of the receiver.

Ruby 2.3

> datetime = DateTime.strptime('2017-05-16 10:15:30 +09:00', '%Y-%m-%d %H:%M:%S %Z') #=> #<DateTime: 2017-05-16T10:15:30+09:00 ((2457890j,4530s,0n),+32400s,2299161j)>> datetime.to_time #=> 2017-05-16 06:45:30 +0530> time = Time.new(2017, 5, 16, 10, 15, 30, '+09:00') #=> 2017-05-16 10:15:30 +0900> time.to_time #=> 2017-05-16 06:45:30 +0530

As you can see, DateTime#to_time and Time#to_time methods return time insystem timezone offset +0530.

Ruby 2.4 fixedDateTime#to_timeandTime#to_time.

Now, DateTime#to_time and Time#to_time preserve receiver's timezone offsetinfo.

Ruby 2.4

> datetime = DateTime.strptime('2017-05-16 10:15:30 +09:00', '%Y-%m-%d %H:%M:%S %Z') #=> #<DateTime: 2017-05-16T10:15:30+09:00 ((2457890j,4530s,0n),+32400s,2299161j)>> datetime.to_time #=> 2017-05-16 10:15:30 +0900> time = Time.new(2017, 5, 16, 10, 15, 30, '+09:00') #=> 2017-05-16 10:15:30 +0900> time.to_time #=> 2017-05-16 10:15:30 +0900

Since this is a breaking change for Rails application upgrading to ruby 2.4,Rails 4.2.8 built a compatibility layer by adding aconfig option.ActiveSupport.to_time_preserves_timezone was added to control how to_timehandles timezone offsets.

Here is an example of how application behaves when to_time_preserves_timezoneis set to false.

> ActiveSupport.to_time_preserves_timezone = false> datetime = DateTime.strptime('2017-05-16 10:15:30 +09:00', '%Y-%m-%d %H:%M:%S %Z') #=> Tue, 16 May 2017 10:15:30 +0900> datetime.to_time #=> 2017-05-16 06:45:30 +0530> time = Time.new(2017, 5, 16, 10, 15, 30, '+09:00') #=> 2017-05-16 10:15:30 +0900> time.to_time #=> 2017-05-16 06:45:30 +0530

Here is an example of how application behaves when to_time_preserves_timezoneis set to true.

> ActiveSupport.to_time_preserves_timezone = true> datetime = DateTime.strptime('2017-05-16 10:15:30 +09:00', '%Y-%m-%d %H:%M:%S %Z') #=> Tue, 16 May 2017 10:15:30 +0900> datetime.to_time #=> 2017-05-16 10:15:30 +0900> time = Time.new(2017, 5, 16, 10, 15, 30, '+09:00') #=> 2017-05-16 10:15:30 +0900> time.to_time #=> 2017-05-16 10:15:30 +0900

> 1.dupTypeError: can't dup Fixnumfrom (irb):1:in `dup'from (irb):1

This was confusing because Integer#dup is actually implemented.

> Integer.respond_to? :dup=> true

However, if we were to freeze an Integer it would fail silently.

> 1.freeze=> 1

Ruby 2.4 has now included dup-ability for Integer as well.

> 1.dup=> 1

In Ruby, some object types are immediate variables and therefore cannot beduped/cloned. Yet, there was no graceful way of averting the error thrown by thesanity check when we attempt to dup/clone them.

So now Integer#dup functions exactly the way freeze does -- fail silentlyand return the object itself. It makes sense because nothing about these objectscan be changed in the first place.

In Ruby 2.3, behavior of these methods was inconsistent. Let's see an example.

# Ruby 2.3>> IPAddr.new("1.2.1.3") == "Some ip address"=> IPAddr::InvalidAddressError: invalid address

But if the first argument is invalid IP address and second is valid IP address,then it would return false.

# Ruby 2.3>> "Some ip address" == IPAddr.new("1.2.1.3")=> false

The <=> method would raise exception in both the cases.

# Ruby 2.3>> "Some ip address" <=> IPAddr.new("1.2.1.3")=> IPAddr::InvalidAddressError: invalid address>> IPAddr.new("1.2.1.3") <=> "Some ip address"=> IPAddr::InvalidAddressError: invalid address

In Ruby 2.4, this issue isfixedfor both the methods to return the result without raising exception, if theobjects being compared can't be converted to an IPAddr object.

# Ruby 2.4>> IPAddr.new("1.2.1.3") == "Some ip address"=> false>> "Some ip address" == IPAddr.new("1.2.1.3")=> false>> IPAddr.new("1.2.1.3") <=> "Some ip address"=> nil>> "Some ip address" <=> IPAddr.new("1.2.1.3")=> nil

This might cause some backward compatibility if our code is expecting theexception which is no longer raised in Ruby 2.4.

In Ruby 2.4, these constants aredeprecated and will be removed infuture version.

# Ruby 2.32.3.1 :001 > TRUE => true2.3.1 :002 > FALSE => false2.3.1 :003 > NIL => nil

# Ruby 2.42.4.0 :001 > TRUE(irb):1: warning: constant ::TRUE is deprecated => true2.4.0 :002 > FALSE(irb):2: warning: constant ::FALSE is deprecated => false2.4.0 :003 > NIL(irb):3: warning: constant ::NIL is deprecated => nil

daily_logger = Logger.new('foo.log', 'daily')weekly_logger = Logger.new('foo.log', 'weekly')monthly_logger = Logger.new('foo.log', 'monthly')

At the end of the specified period, Ruby will change the file extension of thelog file as follows:

foo.log.20170615

The format of the suffix for the rotated log file is %Y%m%d. In Ruby 2.3,there was no way to customize this suffix format.

Ruby 2.4added the abilityto customize the suffix format by passing an extra argumentshift_period_suffix.

# Ruby 2.4logger = Logger.new('foo.log', 'weekly', shift_period_suffix: '%d-%m-%Y')

Now, suffix of the rotated log file will use the custom date format which wepassed.

foo.log.15-06-2017

{ a: 1, b: 2, c: 3 } => { a: 2, b: 4, c: 6 }{ a: "B", c: "D", e: "F" } => { a: "b", c: "d", e: "f" }

We can transform the values of a hash destructively (i.e. modify the originalhash with new values) or non-destructively (i.e. return a new hash instead ofmodifying the original hash).

Prior to Ruby 2.4, we need to use following code to transform the values of ahash.

# Ruby 2.3 Non-destructive version> hash = { a: 1, b: 2, c: 3 } #=> {:a=>1, :b=>2, :c=>3}> hash.inject({}) { |h, (k, v)| h[k] = v * 2; h } #=> {:a=>2, :b=>4, :c=>6}> hash #=> {:a=>1, :b=>2, :c=>3}> hash = { a: "B", c: "D", e: "F" } #=> {:a=>"B", :c=>"D", :e=>"F"}> hash.inject({}) { |h, (k, v)| h[k] = v.downcase; h } #=> {:a=>"b", :c=>"d", :e=>"f"}> hash #=> {:a=>"B", :c=>"D", :e=>"F"}

# Ruby 2.3 Destructive version> hash = { a: 1, b: 2, c: 3 } #=> {:a=>1, :b=>2, :c=>3}> hash.each { |k, v| hash[k] = v * 2 } #=> {:a=>2, :b=>4, :c=>6}> hash #=> {:a=>2, :b=>4, :c=>6}> hash = { a: "B", c: "D", e: "F" } #=> {:a=>"B", :c=>"D", :e=>"F"}> hash.each { |k, v| hash[k] = v.downcase } #=> {:a=>"b", :c=>"d", :e=>"f"}> hash #=> {:a=>"b", :c=>"d", :e=>"f"}

transform_values and transform_values! from Active Support

Active Support has already implemented handy methodsHash#transform_values and Hash#transform_values!to transform hash values.

Now, Ruby 2.4 has also implementedHash#map_v and Hash#map_v!and then renamed toHash#transform_values and Hash#transform_values!for the same purpose.

# Ruby 2.4 Non-destructive version> hash = { a: 1, b: 2, c: 3 } #=> {:a=>1, :b=>2, :c=>3}> hash.transform_values { |v| v * 2 } #=> {:a=>2, :b=>4, :c=>6}> hash #=> {:a=>1, :b=>2, :c=>3}> hash = { a: "B", c: "D", e: "F" } #=> {:a=>"B", :c=>"D", :e=>"F"}> hash.transform_values(&:downcase) #=> {:a=>"b", :c=>"d", :e=>"f"}> hash #=> {:a=>"B", :c=>"D", :e=>"F"}

# Ruby 2.4 Destructive version> hash = { a: 1, b: 2, c: 3 } #=> {:a=>1, :b=>2, :c=>3}> hash.transform_values! { |v| v * 2 } #=> {:a=>2, :b=>4, :c=>6}> hash #=> {:a=>2, :b=>4, :c=>6}> hash = { a: "B", c: "D", e: "F" } #=> {:a=>"B", :c=>"D", :e=>"F"}> hash.transform_values!(&:downcase) #=> {:a=>"b", :c=>"d", :e=>"f"}> hash #=> {:a=>"b", :c=>"d", :e=>"f"}

pry did make our lives easier with the usage ofbinding.pry. However, it was still a bit of an inconvenience to have itinstalled at runtime, while working with the irb.

Ruby 2.4 has now introduced binding.irb. By simply adding binding.irb to ourcode we can open an IRB session.

class ConvolutedProcessdef do_something@variable = 10    binding.irb    # opens a REPL hereendendirb(main):029:0\* ConvolutedProcess.new.do_somethingirb(#<ConvolutedProcess:0x007fc55c827f48>):001:0> @variable=> 10

After creating the logger object we need to set its level.

Ruby 2.3

require 'logger'logger = Logger.new(STDOUT)logger.level = Logger::INFO

If we are working with ActiveRecord::Base.logger, then same code would looksomething like this.

require 'logger'ActiveRecord::Base.logger = Logger.new(STDOUT)ActiveRecord::Base.logger.level = Logger::INFO

As we can see in the both the cases we need to set the level separately afterinstantiating the object.

Ruby 2.4

In Ruby 2.4, level can now be specified in the constructor.

#ruby 2.4require 'logger'logger = Logger.new(STDOUT, level: Logger::INFO)# let's verify itlogger.level      #=> 1

Similarly, other options such as progname, formatter and datetime_format,which prior to Ruby 2.4 had to be explicitly set, can now be set during theinstantiation.

#ruby 2.3require 'logger'logger = Logger.new(STDOUT)logger.level = Logger::INFOlogger.progname = 'bigbinary'logger.datetime_format = '%Y-%m-%d %H:%M:%S'logger.formatter = proc do |severity, datetime, progname, msg|  "#{severity} #{datetime} ==> App: #{progname}, Message: #{msg}\n"endlogger.info("Program started...")#=> INFO 2017-03-16 18:43:58 +0530 ==> App: bigbinary, Message: Program started...

Here is same stuff in Ruby 2.4.

#ruby 2.4require 'logger'logger = Logger.new(STDOUT,  level: Logger::INFO,  progname: 'bigbinary',  datetime_format: '%Y-%m-%d %H:%M:%S',  formatter: proc do |severity, datetime, progname, msg|    "#{severity} #{datetime} ==> App: #{progname}, Message: #{msg}\n"  end)logger.info("Program started...")#=> INFO 2017-03-16 18:47:39 +0530 ==> App: bigbinary, Message: Program started...

Tempfileis used for managing temporary files in Ruby. A Tempfile object creates atemporary file with a unique filename. It behaves just like a File object, andtherefore we can perform all the usual file operations on it.

Why Tempfile when we can use File

These days it is common to store file on services like S3. Let's say that wehave a users.csv file on S3. Working with this file remotely is problematic.In such cases it is desirable to download the file on local machine formanipulation. After the work is done then file should be deleted. Tempfile isideal for such cases.

Basename for tempfile

If we want to create a temporary file then we needed to pass parameter to itprior to Ruby 2.3.

require 'tempfile'file = Tempfile.new('bigbinary')#=> #<Tempfile:/var/folders/jv/fxkfk9_10nb_964rvrszs2540000gn/T/bigbinary-20170304-10828-1w02mqi>

As we can see above the generated file name begins with "bigbinary" word.

Since Tempfile ensures that the generate filename will always be unique thepoint of passing the argument is meaningless. Ruby doc calls this passing"basename".

So in Ruby 2.3.0 it was decided thatthe basename parameter was meaningless for Tempfile#new and an empty stringwill be the default value.

require 'tempfile'file = Tempfile.new#=> #<Tempfile:/var/folders/jv/fxkfk9_10nb_964rvrszs2540000gn/T/20170304-10828-1v855bf>

But the same was not implemented for Tempfile#create.

# Ruby 2.3.0require 'tempfile'Tempfile.create do |f|  f.write "hello"endArgumentError: wrong number of arguments (given 0, expected 1..2)

This was fixed in Ruby 2.4. So nowthe basename parameter for Tempfile.create is set to empty string by default,to keep it consistent with the Tempfile#new method.

# Ruby 2.4require 'tempfile'Tempfile.create do |f|  f.write "hello"end=> 5

Ruby 2.3.x

In the previous versions of Ruby, we could use methods such as floor, ceiland truncate in following ways.

5.54.floor          #=> 55.54.ceil           #=> 65.54.truncate       #=> 5

Providing an argument to these methods would result in ArgumentErrorexception.

Ruby 2.4

Ruby community decided to come up with an option toadd precision argument .

The precision argument, which can be negative, helps us to get result to therequired precision to either side of the decimal point.

The default value for the precision argument is 0.

876.543.floor(-2)       #=> 800876.543.floor(-1)       #=> 870876.543.floor           #=> 876876.543.floor(1)        #=> 876.5876.543.floor(2)        #=> 876.54876.543.ceil(-2)        #=> 900876.543.ceil(-1)        #=> 880876.543.ceil            #=> 877876.543.ceil(1)         #=> 876.6876.543.ceil(2)         #=> 876.55876.543.truncate(-2)    #=> 800876.543.truncate(-1)    #=> 870876.543.truncate        #=> 876876.543.truncate(1)     #=> 876.5876.543.truncate(2)     #=> 876.54

These methods all work the same on Integer as well.

5.floor(2)              #=> 5.05.ceil(2)               #=> 5.05.truncate(2)           #=> 5.0

Let's consider an example of countries that have hosted the Olympics. We onlywant to know when was the first time a country hosted it.

# given object{ 1896 => 'Athens',  1900 => 'Paris',  1904 => 'Chicago',  1906 => 'Athens',  1908 => 'Rome' }# expected outcome{ 1896 => 'Athens',  1900 => 'Paris',  1904 => 'Chicago',  1908 => 'Rome' }

One way to achieve this is to have a collection of unique country names and thencheck if that value is already taken while building the result.

olympics ={ 1896 => 'Athens',  1900 => 'Paris',  1904 => 'Chicago',  1906 => 'Athens',  1908 => 'Rome' }unique_nations = olympics.values.uniqolympics.select{ |year, country| !unique_nations.delete(country).nil? }#=> {1896=>"Athens", 1900=>"Paris", 1904=>"Chicago", 1908=>"Rome"}

As we can see, the above code requires constructing an additional arrayunique_nations.

In processing larger data, loading an array of considerably big size in memoryand then carrying out further processing on it, may result in performance andmemory issues.

In Ruby 2.4, Enumerable class introduces uniqmethod that collects unique elementswhile iterating over the enumerable object.

The usage is similar to that of Array#uniq. Uniqueness can be determined by theelements themselves or by a value yielded by the block passed to the uniqmethod.

olympics = {1896 => 'Athens', 1900 => 'Paris', 1904 => 'Chicago', 1906 => 'Athens', 1908 => 'Rome'}olympics.uniq { |year, country| country }.to_h#=> {1896=>"Athens", 1900=>"Paris", 1904=>"Chicago", 1908=>"Rome"}

Similar method is also implemented in Enumerable::Lazy class. Hence we can nowcall uniq on lazy enumerables.

(1..Float::INFINITY).lazy.uniq { |x| (x**2) % 10 }.first(6)#=> [1, 2, 3, 4, 5, 10]

Ruby also has strip method which is a combination of lstrip and rstrip and canbe used to remove both, leading and trailing whitespaces, from a string.

"    Hello World    ".lstrip    #=> "Hello World    ""    Hello World    ".rstrip    #=> "    Hello World""    Hello World    ".strip     #=> "Hello World"

Prior to Ruby 2.4, the rstrip method was optimized for performance, but thelstrip and strip were somehow missed. In Ruby 2.4, String#lstrip andString#strip methods too have beenoptimized to get the performancebenefit of String#rstrip .

Let's run following snippet in Ruby 2.3 and Ruby 2.4 to benchmark and comparethe performance improvement.

require 'benchmark/ips'Benchmark.ips do |bench|  str1 = " " * 10_000_000 + "hello world" + " " * 10_000_000  str2 = str1.dup  str3 = str1.dup  bench.report('String#lstrip') do    str1.lstrip  end  bench.report('String#rstrip') do    str2.rstrip  end  bench.report('String#strip') do    str3.strip  endend

Result for Ruby 2.3

Warming up --------------------------------------       String#lstrip     1.000  i/100ms       String#rstrip     8.000  i/100ms        String#strip     1.000  i/100msCalculating -------------------------------------       String#lstrip     10.989  ( 0.0%) i/s -     55.000  in   5.010903s       String#rstrip     92.514  ( 5.4%) i/s -    464.000  in   5.032208s        String#strip     10.170  ( 0.0%) i/s -     51.000  in   5.022118s

Result for Ruby 2.4

Warming up --------------------------------------       String#lstrip    14.000  i/100ms       String#rstrip     8.000  i/100ms        String#strip     6.000  i/100msCalculating -------------------------------------       String#lstrip    143.424  ( 4.2%) i/s -    728.000  in   5.085311s       String#rstrip     89.150  ( 5.6%) i/s -    448.000  in   5.041301s        String#strip     67.834  ( 4.4%) i/s -    342.000  in   5.051584s

From the above results, we can see that in Ruby 2.4, String#lstrip is around14x faster while String#strip is around 6x faster. String#rstrip asexpected, has nearly the same performance as it was already optimized inprevious versions.

Performance remains same for multi-byte strings

Strings can have single byte or multi-byte characters.

For example L Hello World is a multi-byte string because of the presence of which is a multi-byte character.

'e'.bytesize        #=> 1''.bytesize        #=> 2

Let's do performance benchmarking with string L hello world instead ofhello world.

Result for Ruby 2.3

Warming up --------------------------------------       String#lstrip     1.000  i/100ms       String#rstrip     1.000  i/100ms        String#strip     1.000  i/100msCalculating -------------------------------------       String#lstrip     11.147  ( 9.0%) i/s -     56.000  in   5.034363s       String#rstrip      8.693  ( 0.0%) i/s -     44.000  in   5.075011s        String#strip      5.020  ( 0.0%) i/s -     26.000  in   5.183517s

Result for Ruby 2.4

Warming up --------------------------------------       String#lstrip     1.000  i/100ms       String#rstrip     1.000  i/100ms        String#strip     1.000  i/100msCalculating -------------------------------------       String#lstrip     10.691  ( 0.0%) i/s -     54.000  in   5.055101s       String#rstrip      9.524  ( 0.0%) i/s -     48.000  in   5.052678s        String#strip      4.860  ( 0.0%) i/s -     25.000  in   5.152804s

As we can see, the performance for multi-byte strings is almost the same acrossRuby 2.3 and Ruby 2.4.

Explanation

The optimization introduced is related to how the strings are parsed to detectfor whitespaces. Checking for whitespaces in multi-byte string requires anadditional overhead. So the patchadds an initial condition to check if the string is a single byte string, and ifso, processes it separately.

In most of the cases, the strings are single byte so the performance improvementwould be visible and helpful.

# lotr.txtThree Rings for the Elven-kings under the sky,Seven for the Dwarf-lords in their halls of stone,Nine for Mortal Men doomed to die,One for the Dark Lord on his dark throneIn the Land of Mordor where the Shadows lie.

Ruby 2.3

IO.readlines('lotr.txt')#=> ["Three Rings for the Elven-kings under the sky,\n", "Seven for the Dwarf-lords in their halls of stone,\n", "Nine for Mortal Men doomed to die,\n", "One for the Dark Lord on his dark throne\n", "In the Land of Mordor where the Shadows lie."]

As we can see, the lines in the array have a \n, newline character, which isnot skipped while reading the lines. The newline character needs to be choppedin most of the cases. Prior to Ruby 2.4, it could be done in the following way.

IO.readlines('lotr.txt').map(&:chomp)#=> ["Three Rings for the Elven-kings under the sky,", "Seven for the Dwarf-lords in their halls of stone,", "Nine for Mortal Men doomed to die,", "One for the Dark Lord on his dark throne", "In the Land of Mordor where the Shadows lie."]

Ruby 2.4

Since it was a common requirement, Ruby team decided toadd an optional parameter to thereadlines method. So the same can now be achieved in Ruby 2.4 in the followingway.

IO.readlines('lotr.txt', chomp: true)#=> ["Three Rings for the Elven-kings under the sky,", "Seven for the Dwarf-lords in their halls of stone,", "Nine for Mortal Men doomed to die,", "One for the Dark Lord on his dark throne", "In the Land of Mordor where the Shadows lie."]

Additionally, IO#gets, IO#readline, IO#each_line, IO#foreach methodsalso have been modified to accept an optional chomp flag.

> require 'open-uri'> open('http://www.google.com/gmail')RuntimeError: redirection forbidden: http://www.google.com/gmail -> https://www.google.com/gmail/

To get around this issue, we could useopen_uri_redirectionsgem.

> require 'open-uri'> require 'open_uri_redirections'> open('http://www.google.com/gmail/', :allow_redirections => :safe)=> #<Tempfile:/var/folders/jv/fxkfk9_10nb_964rvrszs2540000gn/T/open-uri20170228-41042-2fffoa>

Ruby 2.4

In Ruby 2.4, this issue is fixed. Sonow http to https redirection is possible using open-uri.

> require 'open-uri'> open('http://www.google.com/gmail')=> #<Tempfile:/var/folders/jv/fxkfk9_10nb_964rvrszs2540000gn/T/open-uri20170228-41077-1bkm1dv>

Note that redirection from https to http will raise an error, like it did inprevious versions, since that has possible security concerns.

Dir.entries("/usr/lib").size == 2       #=> falseDir.entries("/home").size == 2          #=> true

Every directory in Unix filesystem contains at least two entries. These are.(current directory) and ..(parent directory).

Hence, the code above checks if there are only two entries and if so, consider adirectory empty.

Again, this code only works for UNIX filesystems and fails on Windows machines,as Windows directories don't have . or ...

Dir.empty?

Considering all this, Ruby has finallyincluded a new method Dir.empty?that takes directory path as argument and returns boolean as an answer.

Here is an example.

Dir.empty?('/Users/rtdp/Documents/posts')   #=> true

Most importantly this method works correctly in all platforms.

File.empty?

To check if a file is empty, Ruby has File.zero? method. This checks if thefile exists and has zero size.

File.zero?('/Users/rtdp/Documents/todo.txt')    #=> true

After introducing Dir.empty? it makes sense toadd File.empty? as an alias toFile.zero?

File.empty?('/Users/rtdp/Documents/todo.txt')    #=> true

567321.digits#=> [1, 2, 3, 7, 6, 5]567321.digits[3]#=> 7

We can also supply a different base as an argument.

0123.digits(8)#=> [3, 2, 1]0xabcdef.digits(16)#=> [15, 14, 13, 12, 11, 10]

Use case of digits

We can use Integer#digits to sum all the digits in an integer.

123.to_s.chars.map(&:to_i).sum#=> 6123.digits.sum#=> 6

Also while calculating checksums likeLuhn andVerhoeff, Integer#digitswill help in reducing string allocation.

For example:

str1 = "Sample string"str2 = str1.dupstr1.eql?(str2) #=> truestr1.equal?(str2) #=> false

We can see that object ids of the objects are not same.

str1.object_id #=> 70334175057920str2.object_id #=> 70334195702480

In ruby, Set doesnot allow duplicate items in its collection. To determine if two items are equalor not in a Set ruby uses Object#eql? and not Object#equal?.

So if we want to add two different objects with the same values in a set, thatwould not have been possible prior to Ruby 2.4 .

Ruby 2.3

require 'set'set = Set.new #=> #<Set: {}>str1 = "Sample string" #=> "Sample string"str2 = str1.dup #=> "Sample string"set.add(str1) #=> #<Set: {"Sample string"}>set.add(str2) #=> #<Set: {"Sample string"}>

But with the newSet#compare_by_identity method introduced in Ruby 2.4,sets can now compare its values using Object#equal? and check for the exactsame objects.

Ruby 2.4

require 'set'set = Set.new.compare_by_identity #=> #<Set: {}>str1 = "Sample string" #=> "Sample string"str2 = str1.dup #=> "Sample string"set.add(str1) #=> #<Set: {"Sample string"}>set.add(str2) #=> #<Set: {"Sample string", "Sample string"}>

Set#compare_by_identity?

Ruby 2.4 also provides thecompare_by_identity? methodto know if the set will compare its elements by their identity.

require 'set'set1= Set.new #=> #<Set: {}>set2= Set.new.compare_by_identity #=> #<Set: {}>set1.compare_by_identity? #=> falseset2.compare_by_identity? #=> true

We can use MatchData#[] to extract named capture and positional capturegroups.

pattern=/(?<number>\d+) (?<word>\w+)/pattern.match('100 thousand')[:number]#=> "100"pattern=/(\d+) (\w+)/pattern.match('100 thousand')[2]#=> "thousand"

Positional capture groups could also be extracted using MatchData#values_at.

pattern=/(\d+) (\w+)/pattern.match('100 thousand').values_at(2)#=> ["thousand"]

Changes in Ruby 2.4

In Ruby 2.4, we can pass string or symbol to extract named capture groups tomethod #values_at.

pattern=/(?<number>\d+) (?<word>\w+)/pattern.match('100 thousand').values_at(:number)#=> ["100"]

Prior to Ruby 2.4, Float and BigDecimal responded to methods infinite? andfinite?, whereas Fixnum and Bignum did not.

Ruby 2.3

#infinite?5.0.infinite?=> nilFloat::INFINITY.infinite?=> 15.infinite?NoMethodError: undefined method `infinite?' for 5:Fixnum

#finite?5.0.finite?=> true5.finite?NoMethodError: undefined method `finite?' for 5:Fixnum

Ruby 2.4

To make behavior for all the numeric values to be consistent,infinite? and finite? were added to Fixnum and Bignumeven though they would always return nil.

This gives us ability to call these methods irrespective of whether they aresimple numbers or floating numbers.

#infinite?5.0.infinite?=> nilFloat::INFINITY.infinite?=> 15.infinite?=> nil

#finite?5.0.finite?=> true5.finite?=> true

clamp method takes min and max as two arguments to define the range of valuesin which the given argument should be clamped.

Clamping numbers

clamp can be used to keep a number within the range of min, max.

10.clamp(5, 20)=> 1010.clamp(15, 20)=> 1510.clamp(0, 5)=> 5

Clamping strings

Similarly, strings can also be clamped within a range.

"e".clamp("a", "s")=> "e""e".clamp("f", "s")=> "f""e".clamp("a", "c")=> "c""this".clamp("thief", "thin")=> "thin"

Internally, this method relies on applying thespaceship <=> operatorbetween the object and the min & max arguments.

if x <=> min < 0, x = min;if x <=> max > 0 , x = maxelse x

According to RFC 4180, we cannothave unescaped double quotes in CSV input since such data can't be parsed.

We get MalformedCSVError error when the CSV data does not conform to RFC 4180.

Ruby 2.4 has added aliberal parsing option to parse suchbad data. When it is set to true, Ruby will try to parse the data even whenthe data does not conform to RFC 4180.

# Before Ruby 2.4> CSV.parse_line('one,two",three,four')CSV::MalformedCSVError: Illegal quoting in line 1.# With Ruby 2.4> CSV.parse_line('one,two",three,four', liberal_parsing: true)=> ["one", "two\"", "three", "four"]

[1, 4, 7, 10, 2, 6, 15].chunk { |item| item > 5 }.each { |values| p values }=> [false, [1, 4]][true, [7, 10]][false, [2]][true, [6, 15]]

Prior to Ruby 2.4, passing a block to chunk method was must.

array = [1,2,3,4,5,6]array.chunk=> ArgumentError: no block given

Enumerable#chunk without block in Ruby 2.4

In Ruby 2.4, we will be able to usechunk without passing block. It justreturns the enumerator object which we can use to chain further operations.

array = [1,2,3,4,5,6]array.chunk=> <Enumerator: [1, 2, 3, 4, 5, 6]:chunk>

Reasons for this change

Let's take thecase of listingconsecutive integers in an array of ranges.

# Before Ruby 2.4integers = [1,2,4,5,6,7,9,13]integers.enum_for(:chunk).with_index { |x, idx| x - idx }.map do |diff, group|  [group.first, group.last]end=> [[1,2],[4,7],[9,9],[13,13]]

We had to useenum_for here aschunk can't be called without block.

enum_for creates a new enumerator object which will enumerate by calling themethod passed to it. In this case the method passed was chunk.

With Ruby 2.4, we can use chunk method directly without using enum_for as itdoes not require a block to be passed.

# Ruby 2.4integers = [1,2,4,5,6,7,9,13]integers.chunk.with_index { |x, idx| x - idx }.map do |diff, group|  [group.first, group.last]end=> [[1,2],[4,7],[9,9],[13,13]]

# Before Ruby 2.41.class         #=> Fixnum(2 ** 62).class #=> Bignum

In general routine work we don't have to worry about whether the number we aredealing with is Bignum or Fixnum. It's just an implementation detail.

Interestingly, Ruby also has Integer class which is superclass for Fixnumand Bignum.

Starting with Ruby 2.4, Fixnum and Bignumare unified into Integer.

# Ruby 2.41.class         #=> Integer(2 ** 62).class #=> Integer

Starting with Ruby 2.4 usage of Fixnum and Bignum constantsis deprecated.

# Ruby 2.4>> Fixnum(irb):6: warning: constant ::Fixnum is deprecated=> Integer>> Bignum(irb):7: warning: constant ::Bignum is deprecated=> Integer

How to know if a number is Fixnum, Bignum or Integer?

We don't have to worry about this change most of the times in our applicationcode. But libraries like Rails use the class of numbers for taking certaindecisions. These libraries need to support both Ruby 2.4 and previous versionsof Ruby.

Easiest way to know whether the Ruby version is using integer unification or notis to check class of 1.

# Ruby 2.41.class #=> Integer# Before Ruby 2.41.class #=> Fixnum

Look at PR #25056 to see how Railsis handling this case.

Similarly Arel isalso supportingboth Ruby 2.4 and previous versions of Ruby.

(1..10).to_a.max#=> 10(1..10).to_a.method(:max)#=> #<Method: Array(Enumerable)#max>

Ruby 2.4 adds Array#min and Array#maxwhich are much faster than Enumerable#max and Enuermable#min.

Following benchmark is based onhttps://blog.blockscore.com/new-features-in-ruby-2-4.

Benchmark.ips do |bench|  NUM1 = 1_000_000.times.map { rand }  NUM2 = NUM1.dup  ENUM_MAX = Enumerable.instance_method(:max).bind(NUM1)  ARRAY_MAX = Array.instance_method(:max).bind(NUM2)  bench.report('Enumerable#max') do    ENUM_MAX.call  end  bench.report('Array#max') do    ARRAY_MAX.call  end  bench.compare!endWarming up --------------------------------------      Enumerable#max     1.000  i/100ms           Array#max     2.000  i/100msCalculating -------------------------------------      Enumerable#max     17.569  ( 5.7%) i/s -     88.000  in   5.026996s           Array#max     26.703  ( 3.7%) i/s -    134.000  in   5.032562sComparison:           Array#max:       26.7 i/s      Enumerable#max:       17.6 i/s - 1.52x  slowerBenchmark.ips do |bench|  NUM1 = 1_000_000.times.map { rand }  NUM2 = NUM1.dup  ENUM_MIN = Enumerable.instance_method(:min).bind(NUM1)  ARRAY_MIN = Array.instance_method(:min).bind(NUM2)  bench.report('Enumerable#min') do    ENUM_MIN.call  end  bench.report('Array#min') do    ARRAY_MIN.call  end  bench.compare!endWarming up --------------------------------------      Enumerable#min     1.000  i/100ms           Array#min     2.000  i/100msCalculating -------------------------------------      Enumerable#min     18.621  ( 5.4%) i/s -     93.000  in   5.007244s           Array#min     26.902  ( 3.7%) i/s -    136.000  in   5.064815sComparison:           Array#min:       26.9 i/s      Enumerable#min:       18.6 i/s - 1.44x  slower

This benchmark shows that the new methods Array#max and Array#min are about1.5 times faster than Enumerable#max and Enumerable#min.

Similar to Enumerable#max and Enumerable#min, Array#max and Array#minalso assumes that the objects useComparable mixin to definespaceship <=> operator for comparing the elements.

It has methods #names and #captures to return the names used for capturingand the actual captured data respectively.

pattern = /(?<number>\d+) (?<word>\w+)/match_data = pattern.match('100 thousand')#=> #<MatchData "100 thousand" number:"100" word:"thousand">>> match_data.names=> ["number", "word"]>> match_data.captures=> ["100", "thousand"]

If we want all named captures in a key value pair, we have to combine the resultof names and captures.

match_data.names.zip(match_data.captures).to_h#=> {"number"=>"100", "word"=>"thousand"}

Ruby 2.4 adds #named_captures whichreturns both the name and data of the capture groups.

pattern=/(?<number>\d+) (?<word>\w+)/match_data = pattern.match('100 thousand')match_data.named_captures#=> {"number"=>"100", "word"=>"thousand"}

Regexp#===

It returns true/false and sets the $~ global variable.

/stat/ === "case statements"#=> true$~#=> #<MatchData "stat">

Regexp#=~

It returns integer position it matched or nil if no match. It also sets the $~global variable.

/stat/ =~ "case statements"#=> 5$~#=> #<MatchData "stat">

Regexp#match

It returns match data and also sets the $~ global variable.

/stat/.match("case statements")#=> #<MatchData "stat">$~#=> #<MatchData "stat">

Ruby 2.4 adds Regexp#match?

This new method just returnstrue/false and does not set any global variables.

/case/.match?("case statements")#=> true

So Regexp#match? is good option when we are only concerned with the fact thatregex matches or not.

Regexp#match? is also faster than its counterparts as it reduces objectallocation by not creating a back reference and changing $~.

require 'benchmark/ips'Benchmark.ips do |bench|  EMAIL_ADDR = 'disposable.style.email.with+symbol@example.com'  EMAIL_REGEXP_DEVISE = /\A[^@\s]+@([^@\s]+\.)+[^@\W]+\z/  bench.report('Regexp#===') do    EMAIL_REGEXP_DEVISE === EMAIL_ADDR  end  bench.report('Regexp#=~') do    EMAIL_REGEXP_DEVISE =~ EMAIL_ADDR  end  bench.report('Regexp#match') do    EMAIL_REGEXP_DEVISE.match(EMAIL_ADDR)  end  bench.report('Regexp#match?') do    EMAIL_REGEXP_DEVISE.match?(EMAIL_ADDR)  end  bench.compare!end#=> Warming up --------------------------------------#=>          Regexp#===   103.876k i/100ms#=>           Regexp#=~   105.843k i/100ms#=>        Regexp#match    58.980k i/100ms#=>       Regexp#match?   107.287k i/100ms#=> Calculating -------------------------------------#=>          Regexp#===      1.335M ( 9.5%) i/s -      6.648M in   5.038568s#=>           Regexp#=~      1.369M ( 6.7%) i/s -      6.880M in   5.049481s#=>        Regexp#match    709.152k ( 5.4%) i/s -      3.539M in   5.005514s#=>       Regexp#match?      1.543M ( 4.6%) i/s -      7.725M in   5.018696s#=>#=> Comparison:#=>       Regexp#match?:  1542589.9 i/s#=>           Regexp#=~:  1369421.3 i/s - 1.13x  slower#=>          Regexp#===:  1335450.3 i/s - 1.16x  slower#=>        Regexp#match:   709151.7 i/s - 2.18x  slower

[1, 2, 3, 4] => 10{a: 1, b: 6, c: -3} => 4

Active Support already implementsEnumerable#sum

> [1, 2, 3, 4].sum #=> 10> {a: 1, b: 6, c: -3}.sum{ |k, v| v**2 } #=> 46> ['foo', 'bar'].sum # concatenation of strings #=> "foobar"> [[1], ['abc'], [6, 'qwe']].sum # concatenation of arrays #=> [1, "abc", 6, "qwe"]

Until Ruby 2.3, we had to use Active Support to use Enumerable#sum method orwe could use #inject which isused by Active Support under the hood.

Ruby 2.4.0 implementsEnumerable#sumas part of the language itself.

Let's take a look at how sum method fares on some of the enumerable objects inRuby 2.4.

> [1, 2, 3, 4].sum #=> 10> {a: 1, b: 6, c: -3}.sum { |k, v| v**2 } #=> 46> ['foo', 'bar'].sum #=> TypeError: String can't be coerced into Integer> [[1], ['abc'], [6, 'qwe']].sum #=> TypeError: Array can't be coerced into Integer

As we can see, the behavior of Enumerable#sum from Ruby 2.4 is same as that ofActive Support in case of numbers but not the same in case of string or arrayconcatenation. Let's see what is the difference and how we can make it work inRuby 2.4 as well.

Understanding addition/concatenation identity

The Enumerable#sum method takes an optional argument which acts as anaccumulator. Both Active Support and Ruby 2.4 accept this argument.

When identity argument is not passed, 0 is used as default accumulator in Ruby2.4 whereas Active Support uses nil as default accumulator.

Hence in the cases of string and array concatenation, the error occurred in Rubybecause the code attempts to add a string and array respectively to 0.

To overcome this, we need to pass proper addition/concatenation identity as anargument to the sum method.

The addition/concatenation identity of an object can be defined as the valuewith which calling + operation on an object returns the same object.

> ['foo', 'bar'].sum('') #=> "foobar"> [[1], ['abc'], [6, 'qwe']].sum([]) #=> [1, "abc", 6, "qwe"]

What about Rails ?

As we have seen earlier, Ruby 2.4 implements Enumerable#sum favouring numericoperations whereas also supporting non-numeric callers with the identityelement. This behavior is not entirely same as that of Active Support. But stillActive Support can make use of the native sum method whenever possible. There isalready a pull request open whichuses Enumerable#sum from Ruby whenever possible. This will help gain someperformance boost as the Ruby's method is implemented natively in C whereas thatin Active Support is implemented in Ruby.

Ruby 2.3

String#concat and Array#concat

string = "Good"string.concat(" morning")#=> "Good morning"array = ['a', 'b', 'c']array.concat(['d'])#=> ["a", "b", "c", "d"]

String#prepend

string = "Morning"string.prepend("Good ")#=> "Good morning"

Before Ruby 2.4, we could pass only one argument to these methods. So we couldnot add multiple items in one shot.

string = "Good"string.concat(" morning", " to", " you")#=> ArgumentError: wrong number of arguments (given 3, expected 1)

Changes with Ruby 2.4

In Ruby 2.4, we can pass multiple arguments and Ruby processes each argument oneby one.

String#concat and Array#concat

string = "Good"string.concat(" morning", " to", " you")#=> "Good morning to you"array = ['a', 'b']array.concat(['c'], ['d'])#=> ["a", "b", "c", "d"]

String#prepend

string = "you"string.prepend("Good ", "morning ", "to ")#=> "Good morning to you"

These methods work even when no argument is passed unlike in previous versionsof Ruby.

"Good".concat#=> "Good"

Difference between concat and shovel << operator

Though shovel << operator can be used interchangeably with concat when weare calling it once, there is a difference in the behavior when calling itmultiple times.

str = "Ruby"str << strstr#=> "RubyRuby"str = "Ruby"str.concat strstr#=> "RubyRuby"str = "Ruby"str << str << str#=> "RubyRubyRubyRuby"str = "Ruby"str.concat str, strstr#=> "RubyRubyRuby"

So concat behaves as appending present content to the caller twice. Whereascalling << twice is just sequence of binary operations. So the argument forthe second call is output of the first << operation.

{ "name" => "prathamesh", "email" => nil} => { "name" => "prathamesh" }

Active Support already has a solution for this in the form ofHash#compactandHash#compact!.

hash = { "name" => "prathamesh", "email" => nil}hash.compact #=> { "name" => "prathamesh" }hash #=> { "name" => "prathamesh", "email" => nil}hash.compact! #=> { "name" => "prathamesh" }hash #=> { "name" => "prathamesh" }

Now, Ruby 2.4 will have these 2 methods in thelanguageitself, so even those not using Railsor Active Support will be able to use them. Additionally it will also giveperformance boost over the Active Support versions because now these methods areimplemented in C natively whereas the Active Support versions are in Ruby.

There is already apull request open in Rails to usethe native versions of these methods from Ruby 2.4 whenever available so that wewill be able to use the performance boost.