From 323f22e9460d5db3fd4ef3cff51c6a8cb8642bb5 Mon Sep 17 00:00:00 2001
From: schneems <richard.schneeman+foo@gmail.com>
Date: Thu, 18 Oct 2018 15:58:44 -0500
Subject: [PATCH] Refactor

---
 .travis.yml            |  5 ++---
 CHANGELOG.md           |  4 ++++
 lib/get_process_mem.rb | 46 ++++++++++++++++++++++--------------------
 3 files changed, 30 insertions(+), 25 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 20e8ae3..2c9c8da 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,9 +4,8 @@ before_install:
   - gem install bundler -v 1.12.5
 
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
+  - 2.2.0
+  - 2.5.0
   - ruby-head
   - jruby-19mode
   - rbx-19mode
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c64c74f..33e2864 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.2.3
+
+-  Silence BigDecimal deprecation warning under Ruby 2.5 (#26)
+
 ## 0.2.2
 
 - Fix support for Ruby 2.4 (#23)
diff --git a/lib/get_process_mem.rb b/lib/get_process_mem.rb
index 558d25b..cb16acd 100644
--- a/lib/get_process_mem.rb
+++ b/lib/get_process_mem.rb
@@ -3,11 +3,25 @@
 
 # Cribbed from Unicorn Worker Killer, thanks!
 class GetProcessMem
-  KB_TO_BYTE = 1024          # 2**10   = 1024
-  MB_TO_BYTE = 1_048_576     # 1024**2 = 1_048_576
-  GB_TO_BYTE = 1_073_741_824 # 1024**3 = 1_073_741_824
+  if Kernel.respond_to?(:BigDecimal)
+    private_class_method def self.number_to_bigdecimal(value)
+      BigDecimal(value)
+    end
+  else
+    private_class_method def self.number_to_bigdecimal(value)
+      BigDecimal.new(value)
+    end
+  end
+
+  private def number_to_bigdecimal(value)
+    self.class.send(:number_to_bigdecimal, value)
+  end
+
+  KB_TO_BYTE = number_to_bigdecimal 1024          # 2**10   = 1024
+  MB_TO_BYTE = number_to_bigdecimal 1_048_576     # 1024**2 = 1_048_576
+  GB_TO_BYTE = number_to_bigdecimal 1_073_741_824 # 1024**3 = 1_073_741_824
   CONVERSION = { "kb" => KB_TO_BYTE, "mb" => MB_TO_BYTE, "gb" => GB_TO_BYTE }
-  ROUND_UP   = Kernel.respond_to?(:BigDecimal) ? BigDecimal("0.5") : BigDecimal.new("0.5")
+  ROUND_UP   = number_to_bigdecimal "0.5"
   attr_reader :pid
 
   RUNS_ON_WINDOWS = Gem.win_platform?
@@ -40,15 +54,15 @@ def bytes
   end
 
   def kb(b = bytes)
-    (b/coerce_to_big_decimal(KB_TO_BYTE)).to_f
+    (b/KB_TO_BYTE).to_f
   end
 
   def mb(b = bytes)
-    (b/coerce_to_big_decimal(MB_TO_BYTE)).to_f
+    (b/MB_TO_BYTE).to_f
   end
 
   def gb(b = bytes)
-    (b/coerce_to_big_decimal(GB_TO_BYTE)).to_f
+    (b/GB_TO_BYTE).to_f
   end
 
   def inspect
@@ -73,7 +87,7 @@ def linux_memory(file = @process_file)
     return if lines.empty?
     lines.reduce(0) do |sum, line|
       line.match(/(?<value>(\d*\.{0,1}\d+))\s+(?<unit>\w\w)/) do |m|
-        value = coerce_to_big_decimal(m[:value]) + ROUND_UP
+        value = number_to_bigdecimal(m[:value]) + ROUND_UP
         unit  = m[:unit].downcase
         sum  += CONVERSION[unit] * value
       end
@@ -88,22 +102,10 @@ def linux_memory(file = @process_file)
   def ps_memory
     if RUNS_ON_WINDOWS
       size = ProcTable.ps(pid).working_set_size
-      coerce_to_big_decimal(size)
+      number_to_bigdecimal(size)
     else
       mem = `ps -o rss= -p #{pid}`
-      KB_TO_BYTE * coerce_to_big_decimal(mem == "" ? 0 : mem)
+      KB_TO_BYTE * number_to_bigdecimal(mem == "" ? 0 : mem)
     end
   end
-
-  private
-
-  def coerce_to_big_decimal(value)
-    if Kernel.respond_to?(:BigDecimal)
-      #running under Ruby 2.5 or later
-      BigDecimal(value)
-    else
-      BigDecimal.new(value)
-    end
-  end
-
 end