humanize-bytes 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 352f1ea83c8657e52cb904728a2590f16046d29d
-  data.tar.gz: 977d5f597321d04bd045c64a34964e1e482b811d
+  metadata.gz: 695dd5f96cad7054596aa8d4d7b581a6e527afae
+  data.tar.gz: 4ed8d62982c3847555b174d826458d352c418ac7
 SHA512:
-  metadata.gz: ab986f567924b55a5c5fb7468e1e399fd1d088f7090813191a3f3ba00f0907d3b03831bedcbd160e5ad82deb52047bd948ece35938855b00f2f92e0408d6ca9e
-  data.tar.gz: b0052290ed4a4abfe29c9df40444c1b5b82a14455b68ca8df4b0ae71ab67cef48c86364f9ccfa4c46c3531e1f647a7934fcab4f714a94c020d04107cfce6f66d
+  metadata.gz: 125db803fedd3bfa9a60228790477e85eb2cb385d0972f91b5a1017e2d6f790eae88c68c394d2cf3a6711549378e12af7ce6f2caf416c34d7feef765cb1944df
+  data.tar.gz: 65e9c78792058a16e9b154e22181c52568af96a766b66868a1455b5bf12390e93bbf3432ca19e998cd86d394247557675bb4c9d517c7e8268409220862ffad0a

data/.ruby-version

@@ -1 +1 @@
-2.1.2
+2.2.3

data/.travis.yml

@@ -4,4 +4,8 @@ rvm:
   - 1.9.3
   - 2.0
   - 2.1.2
-  - jruby
+  - 2.2.3
+  - jruby
+
+before_install:
+  - gem update bundler

data/README.md

@@ -1,6 +1,6 @@
 # Humanize::Bytes [![Build Status](https://secure.travis-ci.org/plribeiro3000/humanize-bytes.png)](http://travis-ci.org/plribeiro3000/humanize-bytes)
 
-Convert Byte, Kbyte, MByte, Gbyte into each other easy as to_b.
+Convert Byte, KByte, MByte, GByte, TByte, PByte, EByte, ZByte and YByte into each other easy as to_b.
 
 ## Installation
 
@@ -24,7 +24,19 @@ Initialize a New Byte Object with
 Humanize::Byte.new(1024)
 ```
 
-Then call one of the methods: to_b, to_k, to_m, to_g.
+## Conversion Table
+
+| Value | Equivalent | Call Methods |
+|-------|------------|:-----------:|
+| Byte | 1 Byte | to_b |
+| Kilobyte | 1024 Bytes | to_k |
+| Megabyte | 1024 Kilobytes | to_m |
+| Gigabyte | 1024 Megabytes | to_g |
+| Terabyte | 1024 Gigabytes | to_t |
+| Petabyte | 1024 Terabytes | to_p |
+| Exabyte | 1024 Petabytes | to_e |
+| Zettabyte | 1024 Exabytes | to_z |
+| Yottabyte | 1024 Zettabytes | to_y |
 
 ## Contributing
 

data/humanize-bytes.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |gem|
   gem.version     = Humanize::Bytes::VERSION
   gem.authors     = %q{Paulo Henrique Lopes Ribeiro}
   gem.email       = %q{plribeiro3000@gmail.com}
-  gem.summary     = %q{Convert Byte, Kbyte, MByte, Gbyte into each other}
+  gem.summary     = %q{Convert Byte, KByte, MByte, GByte, TByte, PByte, EByte, ZByte and YByte into each other}
 
   gem.files         = `git ls-files`.split($\)
   gem.test_files    = `git ls-files -- {test,spec,features,examples,gemfiles}/*`.split("\n")

data/lib/humanize-bytes.rb

@@ -4,4 +4,9 @@ module Humanize
   autoload :Kilo, 'humanize/kilo'
   autoload :Mega, 'humanize/mega'
   autoload :Giga, 'humanize/giga'
+  autoload :Tera, 'humanize/tera'
+  autoload :Peta, 'humanize/peta'
+  autoload :Exa, 'humanize/exa'
+  autoload :Zetta, 'humanize/zetta'
+  autoload :Yotta, 'humanize/yotta'
 end

data/lib/humanize/byte.rb

@@ -15,5 +15,25 @@ module Humanize
     def to_g
       Giga.new @value / 1024.0 / 1024 / 1024
     end
+
+    def to_t
+      Tera.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
+
+    def to_p
+      Peta.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
+
+    def to_e
+      Exa.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
+
+    def to_z
+      Zetta.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
+
+    def to_y
+      Yotta.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
   end
-end
+end

data/lib/humanize/bytes.rb

@@ -1,6 +1,6 @@
 module Humanize
   class Bytes
-    VERSION = '2.1.0'
+    VERSION = '2.2.0'
 
     def initialize(value)
       @value = value.to_f
@@ -17,4 +17,4 @@ module Humanize
       ("%.#{size}f" % value).to_s
     end
   end
-end
+end

data/lib/humanize/exa.rb

@@ -0,0 +1,39 @@
+module Humanize
+  class Exa < Bytes
+    def to_b
+      Byte.new @value * 1024 * 1024 * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_k
+      Kilo.new @value * 1024 * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_m
+      Mega.new @value * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_g
+      Giga.new @value * 1024 * 1024 * 1024
+    end
+
+    def to_t
+      Tera.new @value * 1024 * 1024
+    end
+
+    def to_p
+      Peta.new @value * 1024
+    end
+
+    def to_e
+      self
+    end
+
+    def to_z
+      Zetta.new @value / 1024.0
+    end
+
+    def to_y
+      Yotta.new @value / 1024.0 / 1024.0
+    end
+  end
+end

data/lib/humanize/giga.rb

@@ -15,5 +15,25 @@ module Humanize
     def to_g
       self
     end
+
+    def to_t
+      Tera.new @value / 1024.0
+    end
+
+    def to_p
+      Peta.new @value / 1024.0 / 1024.0
+    end
+
+    def to_e
+      Exa.new @value / 1024.0 / 1024.0 / 1024.0
+    end
+
+    def to_z
+      Zetta.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
+
+    def to_y
+      Yotta.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
   end
 end

data/lib/humanize/kilo.rb

@@ -15,5 +15,25 @@ module Humanize
     def to_g
       Giga.new @value / 1024.0 / 1024
     end
+
+    def to_t
+      Tera.new @value / 1024.0 / 1024.0 / 1024.0
+    end
+
+    def to_p
+      Peta.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
+
+    def to_e
+      Exa.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
+
+    def to_z
+      Zetta.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
+
+    def to_y
+      Yotta.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
   end
 end

data/lib/humanize/mega.rb

@@ -15,5 +15,25 @@ module Humanize
     def to_g
       Giga.new @value / 1024.0
     end
+
+    def to_t
+      Tera.new @value / 1024.0 / 1024.0
+    end
+
+    def to_p
+      Peta.new @value / 1024.0 / 1024.0 / 1024.0
+    end
+
+    def to_e
+      Exa.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
+
+    def to_z
+      Zetta.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
+
+    def to_y
+      Yotta.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
   end
 end

data/lib/humanize/peta.rb

@@ -0,0 +1,39 @@
+module Humanize
+  class Peta < Bytes
+    def to_b
+      Byte.new @value * 1024 * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_k
+      Kilo.new @value * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_m
+      Mega.new @value * 1024 * 1024 * 1024
+    end
+
+    def to_g
+      Giga.new @value * 1024 * 1024
+    end
+
+    def to_t
+      Tera.new @value * 1024
+    end
+
+    def to_p
+      self
+    end
+
+    def to_e
+      Exa.new @value / 1024.0
+    end
+
+    def to_z
+      Zetta.new @value / 1024.0 / 1024.0
+    end
+
+    def to_y
+      Yotta.new @value / 1024.0 / 1024.0 / 1024.0
+    end
+  end
+end

data/lib/humanize/tera.rb

@@ -0,0 +1,39 @@
+module Humanize
+  class Tera < Bytes
+    def to_b
+      Byte.new @value * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_k
+      Kilo.new @value * 1024 * 1024 * 1024
+    end
+
+    def to_m
+      Mega.new @value * 1024 * 1024
+    end
+
+    def to_g
+      Giga.new @value * 1024
+    end
+
+    def to_t
+      self
+    end
+
+    def to_p
+      Peta.new @value / 1024.0
+    end
+
+    def to_e
+      Exa.new @value / 1024.0 / 1024.0
+    end
+
+    def to_z
+      Zetta.new @value / 1024.0 / 1024.0 / 1024.0
+    end
+
+    def to_y
+      Yotta.new @value / 1024.0 / 1024.0 / 1024.0 / 1024.0
+    end
+  end
+end

data/lib/humanize/yotta.rb

@@ -0,0 +1,39 @@
+module Humanize
+  class Yotta < Bytes
+    def to_b
+      Byte.new @value * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_k
+      Kilo.new @value * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_m
+      Mega.new @value * 1024 * 1024 * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_g
+      Giga.new @value * 1024 * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_t
+      Tera.new @value * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_p
+      Peta.new @value * 1024 * 1024 * 1024
+    end
+
+    def to_e
+      Exa.new @value * 1024 * 1024
+    end
+
+    def to_z
+      Zetta.new @value * 1024
+    end
+
+    def to_y
+      self
+    end
+  end
+end

data/lib/humanize/zetta.rb

@@ -0,0 +1,39 @@
+module Humanize
+  class Zetta < Bytes
+    def to_b
+      Byte.new @value * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_k
+      Kilo.new @value * 1024 * 1024 * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_m
+      Mega.new @value * 1024 * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_g
+      Giga.new @value * 1024 * 1024 * 1024 * 1024
+    end
+
+    def to_t
+      Tera.new @value * 1024 * 1024 * 1024
+    end
+
+    def to_p
+      Peta.new @value * 1024 * 1024
+    end
+
+    def to_e
+      Exa.new @value * 1024
+    end
+
+    def to_z
+      self
+    end
+
+    def to_y
+      Yotta.new @value / 1024.0
+    end
+  end
+end

data/spec/humanize/byte_spec.rb

@@ -48,6 +48,56 @@ describe Humanize::Byte do
     end
   end
 
+  context "#to_t" do
+    it "should convert to Tera bytes" do
+      expect(b.to_t).to be_an_instance_of(Humanize::Tera)
+    end
+
+    it "should convert the value to Tera bytes" do
+      expect(b.to_t.value).to eq(0.0019534524180926383)
+    end
+  end
+
+  context "#to_p" do
+    it "should convert to Peta bytes" do
+      expect(b.to_p).to be_an_instance_of(Humanize::Peta)
+    end
+
+    it "should convert the value to Peta bytes" do
+      expect(b.to_p.value).to eq(0.000001907668377043592)
+    end
+  end
+
+  context "#to_e" do
+    it "should convert to Exa bytes" do
+      expect(b.to_e).to be_an_instance_of(Humanize::Exa)
+    end
+
+    it "should convert the value to Exa bytes" do
+      expect(b.to_e.value).to eq(0.000000001862957399456633)
+    end
+  end
+
+  context "#to_z" do
+    it "should convert to Zetta bytes" do
+      expect(b.to_z).to be_an_instance_of(Humanize::Zetta)
+    end
+
+    it "should convert the value to Zetta bytes" do
+      expect(b.to_z.value).to eq(0.000000000001819294335406868)
+    end
+  end
+
+  context "#to_y" do
+    it "should convert to Yotta bytes" do
+      expect(b.to_y).to be_an_instance_of(Humanize::Yotta)
+    end
+
+    it "should convert the value to Yotta bytes" do
+      expect(b.to_y.value).to eq(0.0000000000000017766546244207696)
+    end
+  end
+
   context "#to_s" do
     context 'without any specification' do
       it "should return a float with all digits" do

data/spec/humanize/exa_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Humanize::Exa do
+  let(:e) { Humanize::Exa.new(205) }
+
+  context "initialize" do
+    it "should convert the number to float" do
+      expect(Humanize::Exa.new('3').value).to be_an_instance_of(Float)
+    end
+  end
+
+  context "#value" do
+    it "should return the value" do
+      expect(e.value).to eq(205)
+    end
+  end
+
+  context "#to_b" do
+    it "should convert to Bytes" do
+      expect(e.to_b).to be_an_instance_of(Humanize::Byte)
+    end 
+
+    it "should convert the value to Byte" do
+      expect(e.to_b.value).to eq(2.3634890844440363e+20)
+    end
+  end
+
+  context "#to_k" do
+    it "should convert to Kilo bytes" do
+      expect(e.to_k).to be_an_instance_of(Humanize::Kilo)
+    end 
+
+    it "should convert the value to Kilo bytes" do
+      expect(e.to_k.value).to eq(230809480902737920)
+    end
+  end
+
+  context "#to_m" do
+    it "should convert to Mega bytes" do
+      expect(e.to_m).to be_an_instance_of(Humanize::Mega)
+    end
+
+    it "should convert the value to Mega bytes" do
+      expect(e.to_m.value).to eq(225399883694080)
+    end
+  end
+
+  context "#to_g" do
+    it "should convert to Giga bytes" do
+      expect(e.to_g).to be_an_instance_of(Humanize::Giga)
+    end
+    
+    it "should convert the value to Giga bytes" do
+      expect(e.to_g.value).to eq(220117073920)
+    end
+  end
+
+  context "#to_t" do
+    it "should convert to Tera bytes" do
+      expect(e.to_t).to be_an_instance_of(Humanize::Tera)
+    end
+
+    it "should convert the value to Tera bytes" do
+      expect(e.to_t.value).to eq(214958080)
+    end
+  end
+
+  context "#to_p" do
+    it "should convert to Peta bytes" do
+      expect(e.to_p).to be_an_instance_of(Humanize::Peta)
+    end
+
+    it "should convert the value to Peta bytes" do
+      expect(e.to_p.value).to eq(209920)
+    end
+  end
+
+  context "#to_e" do
+    it "should return self" do
+      expect(e.to_e).to be e
+    end
+  end
+
+  context "#to_z" do
+    it "should convert to Zetta bytes" do
+      expect(e.to_z).to be_an_instance_of(Humanize::Zetta)
+    end
+
+    it "should convert the value to Zetta bytes" do
+      expect(e.to_z.value).to eq(0.2001953125)
+    end
+  end
+
+  context "#to_y" do
+    it "should convert to Yotta bytes" do
+      expect(e.to_y).to be_an_instance_of(Humanize::Yotta)
+    end
+
+    it "should convert the value to Yotta bytes" do
+      expect(e.to_y.value).to eq(0.00019550323486328125)
+    end
+  end
+
+  context "#to_s" do
+    context 'without any specification' do
+      it "should return a float with all digits" do
+        expect(e.to_s).to eq('205')
+      end
+    end
+
+    context 'with decimal_digits specified' do
+      before :each do
+        @e = Humanize::Exa.new 205.534
+      end
+
+      it "should return a float with specified digits" do
+        expect(@e.to_s(:decimal_digits => 3)).to eq('205.534')
+      end
+    end
+  end
+end

data/spec/humanize/giga_spec.rb

@@ -48,6 +48,56 @@ describe Humanize::Giga do
     end
   end
 
+  context "#to_t" do
+    it "should convert to Tera bytes" do
+      expect(g.to_t).to be_an_instance_of(Humanize::Tera)
+    end
+
+    it "should convert the value to Tera bytes" do
+      expect(g.to_t.value).to eq(0.003173828125)
+    end
+  end
+
+  context "#to_p" do
+    it "should convert to Peta bytes" do
+      expect(g.to_p).to be_an_instance_of(Humanize::Peta)
+    end
+
+    it "should convert the value to Peta bytes" do
+      expect(g.to_p.value).to eq(0.0000030994415283203125)
+    end
+  end
+
+  context "#to_e" do
+    it "should convert to Exa bytes" do
+      expect(g.to_e).to be_an_instance_of(Humanize::Exa)
+    end
+
+    it "should convert the value to Exa bytes" do
+      expect(g.to_e.value).to eq(0.000000003026798367500305)
+    end
+  end
+
+  context "#to_z" do
+    it "should convert to Zetta bytes" do
+      expect(g.to_z).to be_an_instance_of(Humanize::Zetta)
+    end
+
+    it "should convert the value to Zetta bytes" do
+      expect(g.to_z.value).to eq(0.0000000000029558577807620168)
+    end
+  end
+
+  context "#to_y" do
+    it "should convert to Yotta bytes" do
+      expect(g.to_y).to be_an_instance_of(Humanize::Yotta)
+    end
+
+    it "should convert the value to Yotta bytes" do
+      expect(g.to_y.value).to eq(0.000000000000002886579864025407)
+    end
+  end
+
   context "#to_s" do
     context 'without any specification' do
       it "should return a float with all digits" do

data/spec/humanize/kilo_spec.rb

@@ -48,6 +48,56 @@ describe Humanize::Kilo do
     end
   end
 
+  context "#to_t" do
+    it "should convert to Tera bytes" do
+      expect(k.to_t).to be_an_instance_of(Humanize::Tera)
+    end
+
+    it "should convert the value to Tera bytes" do
+      expect(k.to_t.value).to eq(0.000004656612873077393)
+    end
+  end
+
+  context "#to_p" do
+    it "should convert to Peta bytes" do
+      expect(k.to_p).to be_an_instance_of(Humanize::Peta)
+    end
+
+    it "should convert the value to Peta bytes" do
+      expect(k.to_p.value).to eq(0.000000004547473508864641)
+    end
+  end
+
+  context "#to_e" do
+    it "should convert to Exa bytes" do
+      expect(k.to_e).to be_an_instance_of(Humanize::Exa)
+    end
+
+    it "should convert the value to Exa bytes" do
+      expect(k.to_e.value).to eq(0.000000000004440892098500626)
+    end
+  end
+
+  context "#to_z" do
+    it "should convert to Zetta bytes" do
+      expect(k.to_z).to be_an_instance_of(Humanize::Zetta)
+    end
+
+    it "should convert the value to Zetta bytes" do
+      expect(k.to_z.value).to eq(0.000000000000004336808689942018)
+    end
+  end
+
+  context "#to_y" do
+    it "should convert to Yotta bytes" do
+      expect(k.to_y).to be_an_instance_of(Humanize::Yotta)
+    end
+
+    it "should convert the value to Yotta bytes" do
+      expect(k.to_y.value).to eq(4.235164736271502e-18)
+    end
+  end
+
   context "#to_s" do
     context 'without any specification' do
       it "should return a float with all digits" do

data/spec/humanize/mega_spec.rb

@@ -48,6 +48,56 @@ describe Humanize::Mega do
     end
   end
 
+  context "#to_t" do
+    it "should convert to Tera bytes" do
+      expect(m.to_t).to be_an_instance_of(Humanize::Tera)
+    end
+
+    it "should convert the value to Tera bytes" do
+      expect(m.to_t.value).to eq(0.000004656612873077393)
+    end
+  end
+
+  context "#to_p" do
+    it "should convert to Peta bytes" do
+      expect(m.to_p).to be_an_instance_of(Humanize::Peta)
+    end
+
+    it "should convert the value to Peta bytes" do
+      expect(m.to_p.value).to eq(0.000000004547473508864641)
+    end
+  end
+
+  context "#to_e" do
+    it "should convert to Exa bytes" do
+      expect(m.to_e).to be_an_instance_of(Humanize::Exa)
+    end
+
+    it "should convert the value to Exa bytes" do
+      expect(m.to_e.value).to eq(0.000000000004440892098500626)
+    end
+  end
+
+  context "#to_z" do
+    it "should convert to Zetta bytes" do
+      expect(m.to_z).to be_an_instance_of(Humanize::Zetta)
+    end
+
+    it "should convert the value to Zetta bytes" do
+      expect(m.to_z.value).to eq(0.000000000000004336808689942018)
+    end
+  end
+
+  context "#to_y" do
+    it "should convert to Yotta bytes" do
+      expect(m.to_y).to be_an_instance_of(Humanize::Yotta)
+    end
+
+    it "should convert the value to Yotta bytes" do
+      expect(m.to_y.value).to eq(4.235164736271502e-18)
+    end
+  end
+
   context "#to_s" do
     context 'without any specification' do
       it "should return a float with all digits" do

data/spec/humanize/peta_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Humanize::Peta do
+  let(:p) { Humanize::Peta.new(125) }
+
+  context "initialize" do
+    it "should convert the number to float" do
+      expect(Humanize::Peta.new('3').value).to be_an_instance_of(Float)
+    end
+  end
+
+  context "#value" do
+    it "should return the value" do
+      expect(p.value).to eq(125)
+    end
+  end
+
+  context "#to_b" do
+    it "should convert to Bytes" do
+      expect(p.to_b).to be_an_instance_of(Humanize::Byte)
+    end 
+
+    it "should convert the value to Byte" do
+      expect(p.to_b.value).to eq(140737488355328000)
+    end
+  end
+
+  context "#to_k" do
+    it "should convert to Kilo bytes" do
+      expect(p.to_k).to be_an_instance_of(Humanize::Kilo)
+    end 
+
+    it "should convert the value to Kilo bytes" do
+      expect(p.to_k.value).to eq(137438953472000)
+    end
+  end
+
+  context "#to_m" do
+    it "should convert to Mega bytes" do
+      expect(p.to_m).to be_an_instance_of(Humanize::Mega)
+    end
+
+    it "should convert the value to Mega bytes" do
+      expect(p.to_m.value).to eq(134217728000)
+    end
+  end
+
+  context "#to_g" do
+    it "should convert to Giga bytes" do
+      expect(p.to_g).to be_an_instance_of(Humanize::Giga)
+    end
+    
+    it "should convert the value to Giga bytes" do
+      expect(p.to_g.value).to eq(131072000)
+    end
+  end
+
+  context "#to_t" do
+    it "should convert to Tera bytes" do
+      expect(p.to_t).to be_an_instance_of(Humanize::Tera)
+    end
+
+    it "should convert the value to Tera bytes" do
+      expect(p.to_t.value).to eq(128000)
+    end
+  end
+
+  context "#to_p" do
+    it "should return self" do
+      expect(p.to_p).to be p
+    end
+  end
+
+  context "#to_e" do
+    it "should convert to Exa bytes" do
+      expect(p.to_e).to be_an_instance_of(Humanize::Exa)
+    end
+
+    it "should convert the value to Exa bytes" do
+      expect(p.to_e.value).to eq(0.1220703125)
+    end
+  end
+
+  context "#to_z" do
+    it "should convert to Zetta bytes" do
+      expect(p.to_z).to be_an_instance_of(Humanize::Zetta)
+    end
+
+    it "should convert the value to Zetta bytes" do
+      expect(p.to_z.value).to eq(0.00011920928955078125)
+    end
+  end
+
+  context "#to_y" do
+    it "should convert to Yotta bytes" do
+      expect(p.to_y).to be_an_instance_of(Humanize::Yotta)
+    end
+
+    it "should convert the value to Yotta bytes" do
+      expect(p.to_y.value).to eq(0.00000011641532182693481)
+    end
+  end
+
+  context "#to_s" do
+    context 'without any specification' do
+      it "should return a float with all digits" do
+        expect(p.to_s).to eq('125')
+      end
+    end
+
+    context 'with decimal_digits specified' do
+      before :each do
+        @p = Humanize::Peta.new 125.532
+      end
+
+      it "should return a float with specified digits" do
+        expect(@p.to_s(:decimal_digits => 3)).to eq('125.532')
+      end
+    end
+  end
+end

data/spec/humanize/tera_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Humanize::Tera do
+  let(:t) { Humanize::Tera.new(100) }
+
+  context "initialize" do
+    it "should convert the number to float" do
+      expect(Humanize::Tera.new('3').value).to be_an_instance_of(Float)
+    end
+  end
+
+  context "#value" do
+    it "should return the value" do
+      expect(t.value).to eq(100)
+    end
+  end
+
+  context "#to_b" do
+    it "should convert to Bytes" do
+      expect(t.to_b).to be_an_instance_of(Humanize::Byte)
+    end 
+
+    it "should convert the value to Byte" do
+      expect(t.to_b.value).to eq(109951162777600)
+    end
+  end
+
+  context "#to_k" do
+    it "should convert to Kilo bytes" do
+      expect(t.to_k).to be_an_instance_of(Humanize::Kilo)
+    end 
+
+    it "should convert the value to Kilo bytes" do
+      expect(t.to_k.value).to eq(107374182400)
+    end
+  end
+
+  context "#to_m" do
+    it "should convert to Mega bytes" do
+      expect(t.to_m).to be_an_instance_of(Humanize::Mega)
+    end
+
+    it "should convert the value to Mega bytes" do
+      expect(t.to_m.value).to eq(104857600)
+    end
+  end
+
+  context "#to_g" do
+    it "should convert to Giga bytes" do
+      expect(t.to_g).to be_an_instance_of(Humanize::Giga)
+    end
+
+    it "should convert the value to Giga bytes" do
+      expect(t.to_g.value).to eq(102400)
+    end
+  end
+
+  context "#to_t" do
+    it "should return self" do
+      expect(t.to_t).to be t
+    end
+  end
+
+  context "#to_p" do
+    it "should convert to Peta bytes" do
+      expect(t.to_p).to be_an_instance_of(Humanize::Peta)
+    end
+
+    it "should convert the value to Peta bytes" do
+      expect(t.to_p.value).to eq(0.09765625)
+    end
+  end
+
+  context "#to_e" do
+    it "should convert to Exa bytes" do
+      expect(t.to_e).to be_an_instance_of(Humanize::Exa)
+    end
+
+    it "should convert the value to Exa bytes" do
+      expect(t.to_e.value).to eq(0.000095367431640625)
+    end
+  end
+
+  context "#to_z" do
+    it "should convert to Zetta bytes" do
+      expect(t.to_z).to be_an_instance_of(Humanize::Zetta)
+    end
+
+    it "should convert the value to Zetta bytes" do
+      expect(t.to_z.value).to eq(0.00000009313225746154785)
+    end
+  end
+
+  context "#to_y" do
+    it "should convert to Yotta bytes" do
+      expect(t.to_y).to be_an_instance_of(Humanize::Yotta)
+    end
+
+    it "should convert the value to Yotta bytes" do
+      expect(t.to_y.value).to eq(0.00000000009094947017729282)
+    end
+  end
+
+  context "#to_s" do
+    context 'without any specification' do
+      it "should return a float with all digits" do
+        expect(t.to_s).to eq('100')
+      end
+    end
+
+    context 'with decimal_digits specified' do
+      before :each do
+        @t = Humanize::Tera.new 100.05
+      end
+
+      it "should return a float with specified digits" do
+        expect(@t.to_s(:decimal_digits => 2)).to eq('100.05')
+      end
+    end
+  end
+end

data/spec/humanize/yotta_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Humanize::Yotta do
+  let(:y) { Humanize::Yotta.new(7) }
+
+  context "initialize" do
+    it "should convert the number to float" do
+      expect(Humanize::Yotta.new('3').value).to be_an_instance_of(Float)
+    end
+  end
+
+  context "#value" do
+    it "should return the value" do
+      expect(y.value).to eq(7)
+    end
+  end
+
+  context "#to_b" do
+    it "should convert to Bytes" do
+      expect(y.to_b).to be_an_instance_of(Humanize::Byte)
+    end 
+
+    it "should convert the value to Byte" do
+      expect(y.to_b.value).to eq(8.462480737302404e+24)
+    end
+  end
+
+  context "#to_k" do
+    it "should convert to Kilo bytes" do
+      expect(y.to_k).to be_an_instance_of(Humanize::Kilo)
+    end 
+
+    it "should convert the value to Kilo bytes" do
+      expect(y.to_k.value).to eq(8.264141345021879e+21)
+    end
+  end
+
+  context "#to_m" do
+    it "should convert to Mega bytes" do
+      expect(y.to_m).to be_an_instance_of(Humanize::Mega)
+    end
+
+    it "should convert the value to Mega bytes" do
+      expect(y.to_m.value).to eq(8.070450532247929e+18)
+    end
+  end
+
+  context "#to_g" do
+    it "should convert to Giga bytes" do
+      expect(y.to_g).to be_an_instance_of(Humanize::Giga)
+    end
+    
+    it "should convert the value to Giga bytes" do
+      expect(y.to_g.value).to eq(7.881299347898368e+15)
+    end
+  end
+
+  context "#to_t" do
+    it "should convert to Tera bytes" do
+      expect(y.to_t).to be_an_instance_of(Humanize::Tera)
+    end
+
+    it "should convert the value to Tera bytes" do
+      expect(y.to_t.value).to eq(7696581394432)
+    end
+  end
+
+  context "#to_p" do
+    it "should convert to Peta bytes" do
+      expect(y.to_p).to be_an_instance_of(Humanize::Peta)
+    end
+
+    it "should convert the value to Peta bytes" do
+      expect(y.to_p.value).to eq(7516192768)
+    end
+  end
+
+  context "#to_e" do
+    it "should convert to Exa bytes" do
+      expect(y.to_e).to be_an_instance_of(Humanize::Exa)
+    end
+
+    it "should convert the value to Exa bytes" do
+      expect(y.to_e.value).to eq(7340032)
+    end
+  end
+
+  context "#to_z" do
+    it "should convert to Zetta bytes" do
+      expect(y.to_z).to be_an_instance_of(Humanize::Zetta)
+    end
+
+    it "should convert the value to Zetta bytes" do
+      expect(y.to_z.value).to eq(7168)
+    end
+  end
+
+  context "#to_y" do
+    it "should return self" do
+      expect(y.to_y).to be y
+    end
+  end
+
+  context "#to_s" do
+    context 'without any specification' do
+      it "should return a float with all digits" do
+        expect(y.to_s).to eq('7')
+      end
+    end
+
+    context 'with decimal_digits specified' do
+      before :each do
+        @y = Humanize::Yotta.new 7.13
+      end
+
+      it "should return a float with specified digits" do
+        expect(@y.to_s(:decimal_digits => 2)).to eq('7.13')
+      end
+    end
+  end
+end

data/spec/humanize/zetta_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Humanize::Zetta do
+  let(:z) { Humanize::Zetta.new(35) }
+
+  context "initialize" do
+    it "should convert the number to float" do
+      expect(Humanize::Zetta.new('3').value).to be_an_instance_of(Float)
+    end
+  end
+
+  context "#value" do
+    it "should return the value" do
+      expect(z.value).to eq(35)
+    end
+  end
+
+  context "#to_b" do
+    it "should convert to Bytes" do
+      expect(z.to_b).to be_an_instance_of(Humanize::Byte)
+    end 
+
+    it "should convert the value to Byte" do
+      expect(z.to_b.value).to eq(4.1320706725109396e+22)
+    end
+  end
+
+  context "#to_k" do
+    it "should convert to Kilo bytes" do
+      expect(z.to_k).to be_an_instance_of(Humanize::Kilo)
+    end 
+
+    it "should convert the value to Kilo bytes" do
+      expect(z.to_k.value).to eq(4.0352252661239644e+19)
+    end
+  end
+
+  context "#to_m" do
+    it "should convert to Mega bytes" do
+      expect(z.to_m).to be_an_instance_of(Humanize::Mega)
+    end
+
+    it "should convert the value to Mega bytes" do
+      expect(z.to_m.value).to eq(3.940649673949184e+16)
+    end
+  end
+
+  context "#to_g" do
+    it "should convert to Giga bytes" do
+      expect(z.to_g).to be_an_instance_of(Humanize::Giga)
+    end
+    
+    it "should convert the value to Giga bytes" do
+      expect(z.to_g.value).to eq(38482906972160)
+    end
+  end
+
+  context "#to_t" do
+    it "should convert to Tera bytes" do
+      expect(z.to_t).to be_an_instance_of(Humanize::Tera)
+    end
+
+    it "should convert the value to Tera bytes" do
+      expect(z.to_t.value).to eq(37580963840)
+    end
+  end
+
+  context "#to_p" do
+    it "should convert to Peta bytes" do
+      expect(z.to_p).to be_an_instance_of(Humanize::Peta)
+    end
+
+    it "should convert the value to Peta bytes" do
+      expect(z.to_p.value).to eq(36700160)
+    end
+  end
+
+  context "#to_e" do
+    it "should convert to Exa bytes" do
+      expect(z.to_e).to be_an_instance_of(Humanize::Exa)
+    end
+
+    it "should convert the value to Exa bytes" do
+      expect(z.to_e.value).to eq(35840)
+    end
+  end
+
+  context "#to_z" do
+    it "should return self" do
+      expect(z.to_z).to be z
+    end
+  end
+
+  context "#to_y" do
+    it "should convert to Yotta bytes" do
+      expect(z.to_y).to be_an_instance_of(Humanize::Yotta)
+    end
+
+    it "should convert the value to Yotta bytes" do
+      expect(z.to_y.value).to eq(0.0341796875)
+    end
+  end
+
+  context "#to_s" do
+    context 'without any specification' do
+      it "should return a float with all digits" do
+        expect(z.to_s).to eq('35')
+      end
+    end
+
+    context 'with decimal_digits specified' do
+      before :each do
+        @z = Humanize::Zetta.new 35.15
+      end
+
+      it "should return a float with specified digits" do
+        expect(@z.to_s(:decimal_digits => 2)).to eq('35.15')
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: humanize-bytes
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Paulo Henrique Lopes Ribeiro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-13 00:00:00.000000000 Z
+date: 2015-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -71,13 +71,23 @@ files:
 - lib/humanize-bytes.rb
 - lib/humanize/byte.rb
 - lib/humanize/bytes.rb
+- lib/humanize/exa.rb
 - lib/humanize/giga.rb
 - lib/humanize/kilo.rb
 - lib/humanize/mega.rb
+- lib/humanize/peta.rb
+- lib/humanize/tera.rb
+- lib/humanize/yotta.rb
+- lib/humanize/zetta.rb
 - spec/humanize/byte_spec.rb
+- spec/humanize/exa_spec.rb
 - spec/humanize/giga_spec.rb
 - spec/humanize/kilo_spec.rb
 - spec/humanize/mega_spec.rb
+- spec/humanize/peta_spec.rb
+- spec/humanize/tera_spec.rb
+- spec/humanize/yotta_spec.rb
+- spec/humanize/zetta_spec.rb
 - spec/spec_helper.rb
 homepage: 
 licenses:
@@ -99,13 +109,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
-summary: Convert Byte, Kbyte, MByte, Gbyte into each other
+summary: Convert Byte, KByte, MByte, GByte, TByte, PByte, EByte, ZByte and YByte into
+  each other
 test_files:
 - spec/humanize/byte_spec.rb
+- spec/humanize/exa_spec.rb
 - spec/humanize/giga_spec.rb
 - spec/humanize/kilo_spec.rb
 - spec/humanize/mega_spec.rb
+- spec/humanize/peta_spec.rb
+- spec/humanize/tera_spec.rb
+- spec/humanize/yotta_spec.rb
+- spec/humanize/zetta_spec.rb
 - spec/spec_helper.rb