humanize-bytes 1.0.0 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f822f2ca03aaef2328c13d7695900d9a8c56a410
+  data.tar.gz: ec6452119bbedd0ed6bf35d78904c0a35fb29081
+SHA512:
+  metadata.gz: 2ccc4c753f4801f4fb244d3c5b758e52b44d27d93552e7772415222c0682ce34ab56f9297fa52202de8e070cf2a174263c9585bec206678a0fda646e1a353051
+  data.tar.gz: 8bc447ae715d88ca0e1c7ceb7b93f184108cb94c2d9af77c1ac1f23df046aa0672b6ed061c004867fed50a6e0d669a13af61125c5c9152866689ab89b87c44d5

data/.gitignore

@@ -3,6 +3,8 @@
 .bundle
 .config
 .yardoc
+.coveralls.yml
+*.swp
 Gemfile.lock
 InstalledFiles
 _yardoc
@@ -12,6 +14,6 @@ lib/bundler/man
 pkg
 rdoc
 spec/reports
-test/tmp
-test/version_tmp
 tmp
+.*~
+*~

data/.rspec

@@ -1 +1 @@
---colour --format documentation
+--colour --format documentation --profile

data/.ruby-gemset

@@ -0,0 +1 @@
+humanize-bytes

data/.ruby-version

@@ -0,0 +1 @@
+2.1.2

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - 2.0
+  - 2.1.2
+  - jruby

data/README.md

@@ -18,11 +18,11 @@ Or install it yourself as:
 
 ## Usage
 
-Initialize the New Object with
+Initialize a New Byte Object with
 
-    Humanize::Bytes.initialize(1024)
-
-The initialization process accept a second argument which is the unit. Available units are: b, k, m, g
+```ruby
+Humanize::Byte.new(1024)
+```
 
 Then call one of the methods: to_b, to_k, to_m, to_g.
 

data/humanize-bytes.gemspec

@@ -1,20 +1,22 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/humanize-bytes/version', __FILE__)
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'humanize/bytes'
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Paulo Henrique Lopes Ribeiro"]
-  gem.email         = %q{plribeiro3000@gmail.com}
-  gem.description   = %q{Convert Byte, Kbyte, MByte, Gbyte into each other}
-  gem.summary       = %q{Humanize bytes Gem}
-  gem.homepage      = ""
+  gem.name        = 'humanize-bytes'
+  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.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "humanize-bytes"
+  gem.test_files    = `git ls-files -- {test,spec,features,examples,gemfiles}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split('\n').map{ |f| File.basename(f) }
   gem.require_paths = %w(lib)
-  gem.version       = Humanize::Bytes::VERSION
 
-  gem.add_development_dependency "rake"
-  gem.add_development_dependency "rspec", ">= 2.0.0"
+  gem.license = 'MIT'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
 end

data/lib/humanize-bytes.rb

@@ -1,20 +1,7 @@
-require "humanize-bytes/version"
-
 module Humanize
-  module Bytes
-    autoload :Byte, 'humanize-bytes/byte'
-    autoload :Kilo, 'humanize-bytes/kbyte'
-    autoload :Mega, 'humanize-bytes/mbyte'
-    autoload :Giga, 'humanize-bytes/gbyte'
-
-    def self.initialize(value, unit = 'b')
-      case unit.to_s
-        when 'b' then Humanize::Bytes::Byte.new(value)
-        when 'k' then Humanize::Bytes::Kilo.new(value)
-        when 'm' then Humanize::Bytes::Mega.new(value)
-        when 'g' then Humanize::Bytes::Giga.new(value)
-        else nil
-      end
-    end
-  end
+  autoload :Bytes, 'humanize/bytes'
+  autoload :Byte, 'humanize/byte'
+  autoload :Kilo, 'humanize/kilo'
+  autoload :Mega, 'humanize/mega'
+  autoload :Giga, 'humanize/giga'
 end

data/lib/humanize/byte.rb

@@ -0,0 +1,32 @@
+module Humanize
+  class Byte
+    def initialize(value)
+      @value = value
+    end
+
+    def value
+      @value
+    end
+
+    def to_b
+      self
+    end
+
+    def to_k
+      Kilo.new @value / 1024.0
+    end
+
+    def to_m
+      Mega.new @value / 1024.0 / 1024
+    end
+
+    def to_g
+      Giga.new @value / 1024.0 / 1024 / 1024
+    end
+
+    def to_s(options = {})
+      size = options.fetch(:decimal_digits, value.to_s.size)
+      ("%.#{size}f" % value).to_f
+    end
+  end
+end

data/lib/humanize/bytes.rb

@@ -0,0 +1,5 @@
+module Humanize
+  class Bytes
+    VERSION = '2.0.0'
+  end
+end

data/lib/humanize/giga.rb

@@ -0,0 +1,32 @@
+module Humanize
+  class Giga
+    def initialize(value)
+      @value = value
+    end
+
+    def value
+      @value
+    end
+
+    def to_b
+      Byte.new @value * 1024 * 1024 * 1024
+    end
+
+    def to_k
+      Kilo.new @value * 1024 * 1024
+    end
+
+    def to_m
+      Mega.new @value * 1024
+    end
+
+    def to_g
+      self
+    end
+
+    def to_s(options = {})
+      size = options.fetch(:decimal_digits, value.to_s.size)
+      ("%.#{size}f" % value).to_f
+    end
+  end
+end

data/lib/humanize/kilo.rb

@@ -0,0 +1,32 @@
+module Humanize
+  class Kilo
+    def initialize(value)
+      @value = value
+    end
+
+    def value
+      @value
+    end
+
+    def to_b
+      Byte.new @value * 1024
+    end
+
+    def to_k
+      self
+    end
+
+    def to_m
+      Mega.new @value / 1024.0
+    end
+
+    def to_g
+      Giga.new @value / 1024.0 / 1024
+    end
+
+    def to_s(options = {})
+      size = options.fetch(:decimal_digits, value.to_s.size)
+      ("%.#{size}f" % value).to_f
+    end
+  end
+end

data/lib/humanize/mega.rb

@@ -0,0 +1,32 @@
+module Humanize
+  class Mega
+    def initialize(value)
+      @value = value
+    end
+
+    def value
+      @value
+    end
+
+    def to_b
+      Byte.new @value * 1024 * 1024
+    end
+
+    def to_k
+      Kilo.new @value * 1024
+    end
+
+    def to_m
+      self
+    end
+
+    def to_g
+      Giga.new @value / 1024.0
+    end
+
+    def to_s(options = {})
+      size = options.fetch(:decimal_digits, value.to_s.size)
+      ("%.#{size}f" % value).to_f
+    end
+  end
+end

data/spec/humanize/byte_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Humanize::Byte do
+  let(:b) { Humanize::Byte.new(2147843648) }
+
+  context "#value" do
+    it "should return the value" do
+      expect(b.value).to eq(2147843648)
+    end
+  end
+
+  context "#to_b" do
+    it "should return return self" do
+      expect(b.to_b).to be b
+    end
+  end
+
+  context "#to_k" do
+    it "should convert to Kilo bytes" do
+      expect(b.to_k).to be_an_instance_of(Humanize::Kilo)
+    end
+    it "should convert the value to Kilo bytes" do
+      expect(b.to_k.value).to eq(2097503.5625)
+    end
+  end
+
+  context "#to_m" do
+    it "should convert to Mega bytes" do
+      expect(b.to_m).to be_an_instance_of(Humanize::Mega)
+    end
+    it "should convert the value to Mega bytes" do
+      expect(b.to_m.value).to eq(2048.3433227539062)
+    end
+  end
+
+  context "#to_g" do
+    it "should convert to Giga bytes" do
+      expect(b.to_g).to be_an_instance_of(Humanize::Giga)
+    end
+    it "should convert the value to Giga bytes" do
+      expect(b.to_g.value).to eq(2.0003352761268616)
+    end
+  end
+
+  context "#to_s" do
+    context 'without any specification' do
+      it "should return a float with all digits" do
+        expect(b.to_s).to eq(2147843648.0)
+      end
+    end
+
+    context 'with decimal_digits specified' do
+      before :each do
+        @b = Humanize::Byte.new(2147843648.2345)
+      end
+
+      it "should return a float with specified digits" do
+        expect(@b.to_s(:decimal_digits => 2)).to eq(2147843648.23)
+      end
+    end
+  end
+end

data/spec/humanize/giga_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Humanize::Giga do
+  let(:g) { Humanize::Giga.new(3.25) }
+
+  context "#value" do
+    it "should return the value" do
+      expect(g.value).to eq(3.25)
+    end
+  end
+
+  context "#to_b" do
+    it "should convert to Bytes" do
+      expect(g.to_b).to be_an_instance_of(Humanize::Byte)
+    end 
+    it "should convert the value to Byte" do
+      expect(g.to_b.value).to eq(3489660928)
+    end
+  end
+
+  context "#to_k" do
+    it "should convert to Kilo bytes" do
+      expect(g.to_k).to be_an_instance_of(Humanize::Kilo)
+    end 
+    it "should convert the value to Kilo bytes" do
+      expect(g.to_k.value).to eq(3407872)
+    end
+  end
+
+  context "#to_m" do
+    it "should convert to Mega bytes" do
+      expect(g.to_m).to be_an_instance_of(Humanize::Mega)
+    end
+    it "should convert the value to Mega bytes" do
+      expect(g.to_m.value).to eq(3328)
+    end
+  end
+
+  context "#to_g" do
+    it "should return self" do
+      expect(g.to_g).to be g
+    end
+  end
+
+  context "#to_s" do
+    context 'without any specification' do
+      it "should return a float with all digits" do
+        expect(g.to_s).to eq(3.25)
+      end
+    end
+
+    context 'with decimal_digits specified' do
+      before :each do
+        @g = Humanize::Giga.new 3.22
+      end
+
+      it "should return a float with specified digits" do
+        expect(@g.to_s(:decimal_digits => 1)).to eq(3.2)
+      end
+    end
+  end
+end

data/spec/humanize/kilo_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Humanize::Kilo do
+  let(:k) { Humanize::Kilo.new(5000) }
+
+  context "#value" do
+    it "should return the value" do
+      expect(k.value).to eq(5000)
+    end
+  end
+
+  context "#to_b" do
+    it "should convert to Byte" do
+      expect(k.to_b).to be_an_instance_of(Humanize::Byte)
+    end
+    it "should convert the value to Bytes" do
+      expect(k.to_b.value).to eq(5120000)
+    end
+  end
+
+  context "#to_k" do
+    it "should return self" do
+      expect(k.to_k).to be k
+    end
+  end
+
+  context "#to_m" do
+    it "should convert to Mega bytes" do
+      expect(k.to_m).to be_an_instance_of(Humanize::Mega)
+    end
+    it "should convert the value to Mega bytes" do
+      expect(k.to_m.value).to eq(4.8828125)
+    end
+  end
+
+  context "#to_g" do
+    it "should convert to Giga bytes" do
+      expect(k.to_g).to be_an_instance_of(Humanize::Giga)
+    end
+    it "should convert the value to Giga bytes" do
+      expect(k.to_g.value).to eq(0.00476837158203125)
+    end
+  end
+
+  context "#to_s" do
+    context 'without any specification' do
+      it "should return a float with all digits" do
+        expect(k.to_s).to eq(5000.0)
+      end
+    end
+
+    context 'with decimal_digits specified' do
+      before :each do
+        @k = Humanize::Kilo.new(2147843648.2345)
+      end
+
+      it "should return a float with specified digits" do
+        expect(@k.to_s(:decimal_digits => 1)).to eq(2147843648.2)
+      end
+    end
+  end
+end

data/spec/humanize/mega_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Humanize::Mega do
+  let(:m) { Humanize::Mega.new(4.8828125) }
+
+  context "#value" do
+    it "should return the value" do
+      expect(m.value).to eq(4.8828125)
+    end
+  end
+
+  context "#to_b" do
+    it "should convert to Byte" do
+      expect(m.to_b).to be_an_instance_of(Humanize::Byte)
+    end
+    it "should convert the value to Bytes" do
+      expect(m.to_b.value).to eq(5120000)
+    end
+  end
+
+  context "#to_k" do
+    it "should convert to Kilo bytes" do
+      expect(m.to_k).to be_an_instance_of(Humanize::Kilo)
+    end
+    it "should convert the value to Kilo bytes" do
+      expect(m.to_k.value).to eq(5000)
+    end
+  end
+
+  context "#to_m" do
+    it "should return self" do
+      expect(m.to_m).to be m
+    end
+  end
+
+  context "#to_g" do
+    it "should convert to Giga bytes" do
+      expect(m.to_g).to be_an_instance_of(Humanize::Giga)
+    end
+    it "should convert the value to Giga bytes" do
+      expect(m.to_g.value).to eq(0.00476837158203125)
+    end
+  end
+
+  context "#to_s" do
+    context 'without any specification' do
+      it "should return a float with all digits" do
+        expect(m.to_s).to eq(4.8828125)
+      end
+    end
+
+    context 'with decimal_digits specified' do
+      it "should return a float with specified digits" do
+        expect(m.to_s(:decimal_digits => 1)).to eq(4.9)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,4 @@
 require "rubygems"
 require "rspec"
 
-require File.dirname(__FILE__) + "/../lib/humanize-bytes"
-
-include Humanize::Bytes
+require "#{File.dirname(__FILE__)}/../lib/humanize-bytes"

metadata

@@ -1,108 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: humanize-bytes
 version: !ruby/object:Gem::Version
-  version: 1.0.0
-  prerelease: 
+  version: 2.0.0
 platform: ruby
 authors:
 - Paulo Henrique Lopes Ribeiro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-03 00:00:00.000000000 Z
+date: 2014-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
-description: Convert Byte, Kbyte, MByte, Gbyte into each other
+        version: '0'
+description: 
 email: plribeiro3000@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .rvmrc
+- ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
 - Gemfile
-- LICENSE
+- LICENSE.md
 - README.md
 - Rakefile
 - humanize-bytes.gemspec
 - lib/humanize-bytes.rb
-- lib/humanize-bytes/byte.rb
-- lib/humanize-bytes/gbyte.rb
-- lib/humanize-bytes/kbyte.rb
-- lib/humanize-bytes/mbyte.rb
-- lib/humanize-bytes/version.rb
-- spec/humanize_bytes/byte_spec.rb
-- spec/humanize_bytes/gbyte_spec.rb
-- spec/humanize_bytes/kbyte_spec.rb
-- spec/humanize_bytes/mbyte_spec.rb
-- spec/humanize_bytes_spec.rb
+- lib/humanize/byte.rb
+- lib/humanize/bytes.rb
+- lib/humanize/giga.rb
+- lib/humanize/kilo.rb
+- lib/humanize/mega.rb
+- spec/humanize/byte_spec.rb
+- spec/humanize/giga_spec.rb
+- spec/humanize/kilo_spec.rb
+- spec/humanize/mega_spec.rb
 - spec/spec_helper.rb
-homepage: ''
-licenses: []
+homepage: 
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 2054005163981464363
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 2054005163981464363
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
-summary: Humanize bytes Gem
+specification_version: 4
+summary: Convert Byte, Kbyte, MByte, Gbyte into each other
 test_files:
-- spec/humanize_bytes/byte_spec.rb
-- spec/humanize_bytes/gbyte_spec.rb
-- spec/humanize_bytes/kbyte_spec.rb
-- spec/humanize_bytes/mbyte_spec.rb
-- spec/humanize_bytes_spec.rb
+- spec/humanize/byte_spec.rb
+- spec/humanize/giga_spec.rb
+- spec/humanize/kilo_spec.rb
+- spec/humanize/mega_spec.rb
 - spec/spec_helper.rb

data/.rvmrc

@@ -1 +0,0 @@
-rvm use 1.9.3-p194@humanize_bytes --create

data/lib/humanize-bytes/byte.rb

@@ -1,39 +0,0 @@
-module Humanize
-  module Bytes
-    class Byte
-      def initialize(value)
-        @value = value
-      end
-
-      def value
-        @value
-      end
-
-      def to_b
-        self
-      end
-
-      def to_k
-        Kilo.new @value / 1024.0
-      end
-
-      def to_m
-        Mega.new @value / 1024.0 / 1024
-      end
-
-      def to_g
-        Giga.new @value / 1024.0 / 1024 / 1024
-      end
-
-      def to_s
-        @value.instance_of?(Float) ? formatted_float + ' bytes' : @value.to_s + ' bytes'
-      end
-
-      protected
-
-      def formatted_float
-        @value.to_s[0 .. @value.to_s.index('.') + 2]
-      end
-    end
-  end
-end

data/lib/humanize-bytes/gbyte.rb

@@ -1,39 +0,0 @@
-module Humanize
-  module Bytes
-    class Giga
-      def initialize(value)
-        @value = value
-      end
-
-      def value
-        @value
-      end
-
-      def to_b
-        Byte.new @value * 1024 * 1024 * 1024
-      end
-
-      def to_k
-        Kilo.new @value * 1024 * 1024
-      end
-
-      def to_m
-        Mega.new @value * 1024
-      end
-
-      def to_g
-        self
-      end
-
-      def to_s
-        @value.instance_of?(Float) ? formatted_float + ' giga bytes' : @value.to_s + ' giga bytes'
-      end
-
-      protected
-
-      def formatted_float
-        @value.to_s[0 .. @value.to_s.index('.') + 2]
-      end
-    end
-  end
-end

data/lib/humanize-bytes/kbyte.rb

@@ -1,39 +0,0 @@
-module Humanize
-  module Bytes
-    class Kilo
-      def initialize(value)
-        @value = value
-      end
-
-      def value
-        @value
-      end
-
-      def to_b
-        Byte.new @value * 1024
-      end
-
-      def to_k
-        self
-      end
-
-      def to_m
-        Mega.new @value / 1024.0
-      end
-
-      def to_g
-        Giga.new @value / 1024.0 / 1024
-      end
-
-      def to_s
-        @value.instance_of?(Float) ? formatted_float + ' kilo bytes' : @value.to_s + ' kilo bytes'
-      end
-
-      protected
-
-      def formatted_float
-        @value.to_s[0 .. @value.to_s.index('.') + 2]
-      end
-    end
-  end
-end

data/lib/humanize-bytes/mbyte.rb

@@ -1,39 +0,0 @@
-module Humanize
-  module Bytes
-    class Mega
-      def initialize(value)
-        @value = value
-      end
-
-      def value
-        @value
-      end
-
-      def to_b
-        Byte.new @value * 1024 * 1024
-      end
-
-      def to_k
-        Kilo.new @value * 1024
-      end
-
-      def to_m
-        self
-      end
-
-      def to_g
-        Giga.new @value / 1024.0
-      end
-
-      def to_s
-        @value.instance_of?(Float) ? formatted_float + ' mega bytes' : @value.to_s + ' mega bytes'
-      end
-
-      protected
-
-      def formatted_float
-        @value.to_s[0 .. @value.to_s.index('.') + 2]
-      end
-    end
-  end
-end

data/lib/humanize-bytes/version.rb

@@ -1,5 +0,0 @@
-module Humanize
-  module Bytes
-    VERSION = "1.0.0"
-  end
-end

data/spec/humanize_bytes/byte_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe Humanize::Bytes::Byte do
-  let(:b) { Humanize::Bytes::Byte.new(2147843648) }
-
-  context "#value" do
-    it "should return the value" do
-      b.value.should == 2147843648
-    end
-  end
-
-  context "#to_b" do
-    it "should return return self" do
-      b.to_b.should be b
-    end
-  end
-
-  context "#to_k" do
-    it "should convert to Kilo bytes" do
-      b.to_k.class.should be Kilo
-    end
-    it "should convert the value to Kilo bytes" do
-      b.to_k.value.should == 2097503.5625
-    end
-  end
-
-  context "#to_m" do
-    it "should convert to Mega bytes" do
-      b.to_m.class.should be Mega
-    end
-    it "should convert the value to Mega bytes" do
-      b.to_m.value.should ==  2048.3433227539062
-    end
-  end
-
-  context "#to_g" do
-    it "should convert to Giga bytes" do
-      b.to_g.class.should be Giga
-    end 
-    it "should convert the value to Giga bytes" do
-      b.to_g.value.should == 2.0003352761268616
-    end
-  end
-
-  context "#to_s" do
-    context "when value is an integer" do
-      it "should print a humanized version of the value" do
-        b.to_s.should == '2147843648 bytes'
-      end
-    end
-
-    context "when value is an integer" do
-      it "should print a humanized version of the value" do
-        Humanize::Bytes::Byte.new(4.997).to_s.should == '4.99 bytes'
-      end
-    end
-  end
-end

data/spec/humanize_bytes/gbyte_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe Humanize::Bytes::Giga do
-  let(:g) { Humanize::Bytes::Giga.new(3.25) }
-
-  context "#value" do
-    it "should return the value" do
-      g.value.should == 3.25
-    end
-  end
-
-  context "#to_b" do
-    it "should convert to Bytes" do
-      g.to_b.class.should be Byte
-    end 
-    it "should convert the value to Byte" do
-      g.to_b.value.should == 3489660928
-    end
-  end
-
-  context "#to_k" do
-    it "should convert to Kilo bytes" do
-      g.to_k.class.should be Kilo
-    end 
-    it "should convert the value to Kilo bytes" do
-      g.to_k.value.should == 3407872
-    end
-  end
-
-  context "#to_m" do
-    it "should convert to Mega bytes" do
-      g.to_m.class.should be Mega
-    end
-    it "should convert the value to Mega bytes" do
-      g.to_m.value.should == 3328
-    end
-  end
-
-  context "#to_g" do
-    it "should return self" do
-      g.to_g.should be g
-    end
-  end
-
-  context "#to_s" do
-    context "when value is a decimal" do
-      it "should print a humanized version of the value" do
-        g.to_s.should == '3.25 giga bytes'
-      end
-    end
-
-    context "when value is an integer" do
-      it "should print a humanized version of the value" do
-        Humanize::Bytes::Giga.new(4).to_s.should == '4 giga bytes'
-      end
-    end
-  end
-end

data/spec/humanize_bytes/kbyte_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe Humanize::Bytes::Kilo do
-  let(:k) { Humanize::Bytes::Kilo.new(5000) }
-
-  context "#value" do
-    it "should return the value" do
-      k.value.should == 5000
-    end
-  end
-
-  context "#to_b" do
-    it "should convert to Byte" do
-      k.to_b.class.should be Byte
-    end
-    it "should convert the value to Bytes" do
-      k.to_b.value.should == 5120000
-    end
-  end
-
-  context "#to_k" do
-    it "should return self" do
-      k.to_k.should be k
-    end
-  end
-
-  context "#to_m" do
-    it "should convert to Mega bytes" do
-      k.to_m.class.should be Mega
-    end
-    it "should convert the value to Mega bytes" do
-      k.to_m.value.should == 4.8828125
-    end
-  end
-
-  context "#to_g" do
-    it "should convert to Giga bytes" do
-      k.to_g.class.should be Giga
-    end
-    it "should convert the value to Giga bytes" do
-      k.to_g.value.should ==  0.00476837158203125
-    end
-  end
-
-  context "#to_s" do
-    context "when value is an integer" do
-      it "should print a humanized version of the value" do
-        k.to_s.should == '5000 kilo bytes'
-      end
-    end
-
-    context "when value is an integer" do
-      it "should print a humanized version of the value" do
-        Humanize::Bytes::Kilo.new(4.997).to_s.should == '4.99 kilo bytes'
-      end
-    end
-  end
-end

data/spec/humanize_bytes/mbyte_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe Humanize::Bytes::Mega do
-  let(:m) { Humanize::Bytes::Mega.new(4.8828125) }
-
-  context "#value" do
-    it "should return the value" do
-      m.value.should == 4.8828125
-    end
-  end
-
-  context "#to_b" do
-    it "should convert to Byte" do
-      m.to_b.class.should be Byte
-    end
-    it "should convert the value to Bytes" do
-      m.to_b.value.should == 5120000
-    end
-  end
-
-  context "#to_k" do
-    it "should convert to Kilo bytes" do
-      m.to_k.class.should be Kilo
-    end
-    it "should convert the value to Kilo bytes" do
-      m.to_k.value.should == 5000
-    end
-  end
-
-  context "#to_m" do
-    it "should return self" do
-      m.to_m.should be m
-    end
-  end
-
-  context "#to_g" do
-    it "should convert to Giga bytes" do
-      m.to_g.class.should be Giga
-    end
-    it "should convert the value to Giga bytes" do
-      m.to_g.value.should == 0.00476837158203125
-    end
-  end
-
-  context "#to_s" do
-    context "when value is a decimal" do
-      it "should print a humanized version of the value" do
-        m.to_s.should == '4.88 mega bytes'
-      end
-    end
-
-    context "when value is an integer" do
-      it "should print a humanized version of the value" do
-        Humanize::Bytes::Mega.new(4).to_s.should == '4 mega bytes'
-      end
-    end
-  end
-end

data/spec/humanize_bytes_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-describe Humanize::Bytes do
-  describe "#initialize" do
-    context "when the second parameter is nil" do
-      it "should return a new Byte instance" do
-        Humanize::Bytes.initialize(1024).should be_instance_of(Humanize::Bytes::Byte)
-      end
-    end
-
-    context "when the second parameter is 'b'" do
-      it "should return a new Kilo instance" do
-        Humanize::Bytes.initialize(1024, 'b').should be_instance_of(Humanize::Bytes::Byte)
-      end
-    end
-
-    context "when the second parameter is 'k'" do
-      it "should return a new Kilo instance" do
-        Humanize::Bytes.initialize(1024, 'k').should be_instance_of(Humanize::Bytes::Kilo)
-      end
-    end
-
-    context "when the second parameter is 'm'" do
-      it "should return a new Mega instance" do
-        Humanize::Bytes.initialize(1024, 'm').should be_instance_of(Humanize::Bytes::Mega)
-      end
-    end
-
-    context "when the second parameter is 'g'" do
-      it "should return a new Giga instance" do
-        Humanize::Bytes.initialize(1024, 'g').should be_instance_of(Humanize::Bytes::Giga)
-      end
-    end
-
-    context "when the second parameter is :b" do
-      it "should return a new Kilo instance" do
-        Humanize::Bytes.initialize(1024, :b).should be_instance_of(Humanize::Bytes::Byte)
-      end
-    end
-
-    context "when the second parameter is :k" do
-      it "should return a new Kilo instance" do
-        Humanize::Bytes.initialize(1024, :k).should be_instance_of(Humanize::Bytes::Kilo)
-      end
-    end
-
-    context "when the second parameter is :m" do
-      it "should return a new Mega instance" do
-        Humanize::Bytes.initialize(1024, :m).should be_instance_of(Humanize::Bytes::Mega)
-      end
-    end
-
-    context "when the second parameter is :g" do
-      it "should return a new Giga instance" do
-        Humanize::Bytes.initialize(1024, :g).should be_instance_of(Humanize::Bytes::Giga)
-      end
-    end
-
-    context "when the second parameter is any other thing" do
-      it "should return nil" do
-        Humanize::Bytes.initialize(1024, :thing).should be_nil
-      end
-    end
-  end
-end