bytesize 0.1.0

data/lib/bytesize/activerecord.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby -w
+#
+# ByteSize
+#
+# ActiveRecord Type
+#
+# © 2018 Adam Hunt
+# Created: 2018-01-24
+# Modified: 2018-01-24
+#
+
+
+
+require 'bytesize'
+
+
+
+class ByteSize
+	class ActiveRecordType < ActiveRecord::Type::Value
+		
+		def cast( value )
+			value.nil? ? nil : ByteSize.new(value)
+		end
+		
+		def deserialize( value )
+			value.nil? ? nil : ByteSize.new(value)
+		end
+		
+		def serialize( value )
+			value.nil? ? nil : value.to_i
+		end
+		
+	end
+end
+
+ActiveRecord::Type.register( :bytesize, ByteSize::ActiveRecordType )
+
+module ActiveRecord
+	module ConnectionAdapters
+		module MySQL
+			module ColumnMethods
+				
+				def bytesize( *args, **options )
+					args.each{|name| column( name, :bigint, options.merge(unsigned:true) )}
+				end
+				
+			end
+		end
+	end
+end

data/lib/bytesize/units.rb

@@ -0,0 +1,227 @@
+#!/usr/bin/env ruby -w
+#
+# ByteSize
+#
+# Unit-based Numeric convenience methods
+#
+# © 2018 Adam Hunt
+# Created: 2018-01-18
+# Modified: 2018-01-18
+#
+
+
+
+require 'bytesize'
+
+
+
+# Requiring <code>bytesize/units</code> adds convenience methods to
+# {Numeric}[https://ruby-doc.org/stdlib/libdoc/pathname/rdoc/Numeric.html]
+# for easy creation of {ByteSize}[ByteSize.html] and {IECByteSize}[IECByteSize.html] values.
+#
+#
+# === Examples of use
+#
+#   require 'bytesize/units'
+#
+#   1.21.gib       #=> (1.21 GiB)
+#
+#   3.tb           #=> (3 TB)
+#
+#   100.gb         #=> (100 GB)
+#
+#   42.gib.to_mib  #=> 43008.0
+#   
+#   22.gib.to_si   #=> 
+#
+class Numeric
+	
+	
+	
+	# :stopdoc:
+	ByteSize::SI_ORDERS_OF_MAGNITUDE.keys.each do |k|
+		define_method(k.downcase) do
+			ByteSize.send( k.downcase, self )
+		end
+	end
+	
+	IECByteSize::UNIT_SYMBOLS.keys.reject{|k| k == :bytes }.each do |k|
+		define_method(k.downcase) do
+			IECByteSize.send( k.downcase, self )
+		end
+	end
+	# :startdoc:
+	
+	
+	
+	##
+	# :call-seq:
+	#   bytes  ->  bytesize
+	#
+	# Returns a new instance of {ByteSize}[ByteSize.html] representing <em>self</em> number of bytes.
+	#
+	# :method: bytes
+	
+	
+	
+	##
+	# :call-seq:
+	#   kb  ->  bytesize
+	#
+	# Returns a new instance of {ByteSize}[ByteSize.html] representing <em>self</em> number of kilobytes.
+	#
+	# :method: kb
+	
+	
+	
+	##
+	# :call-seq:
+	#   mb  ->  bytesize
+	#
+	# Returns a new instance of {ByteSize}[ByteSize.html] representing <em>self</em> number of megabytes.
+	#
+	# :method: mb
+	
+	
+	
+	##
+	# :call-seq:
+	#   gb  ->  bytesize
+	#
+	# Returns a new instance of {ByteSize}[ByteSize.html] representing <em>self</em> number of gigabytes.
+	#
+	# :method: gb
+	
+	
+	
+	##
+	# :call-seq:
+	#   tb  ->  bytesize
+	#
+	# Returns a new instance of {ByteSize}[ByteSize.html] representing <em>self</em> number of terabytes.
+	#
+	# :method: tb
+	
+	
+	
+	##
+	# :call-seq:
+	#   pb  ->  bytesize
+	#
+	# Returns a new instance of {ByteSize}[ByteSize.html] representing <em>self</em> number of petabytes.
+	#
+	# :method: pb
+	
+	
+	
+	##
+	# :call-seq:
+	#   eb  ->  bytesize
+	#
+	# Returns a new instance of {ByteSize}[ByteSize.html] representing <em>self</em> number of exabytes.
+	#
+	# :method: eb
+	
+	
+	
+	##
+	# :call-seq:
+	#   zb  ->  bytesize
+	#
+	# Returns a new instance of {ByteSize}[ByteSize.html] representing <em>self</em> number of zettabytes.
+	#
+	# :method: zb
+	
+	
+	
+	##
+	# :call-seq:
+	#   yb  ->  bytesize
+	#
+	# Returns a new instance of {ByteSize}[ByteSize.html] representing <em>self</em> number of yottabytes.
+	#
+	# :method: yb
+	
+	
+	
+	##
+	# :call-seq:
+	#   kib  ->  bytesize
+	#
+	# Returns a new instance of {IECByteSize}[IECByteSize.html] representing <em>self</em> number of kibibytes.
+	#
+	# :method: kib
+	
+	
+	
+	##
+	# :call-seq:
+	#   mib  ->  bytesize
+	#
+	# Returns a new instance of {IECByteSize}[IECByteSize.html] representing <em>self</em> number of mebibytes.
+	#
+	# :method: mib
+	
+	
+	
+	##
+	# :call-seq:
+	#   gib  ->  bytesize
+	#
+	# Returns a new instance of {IECByteSize}[IECByteSize.html] representing <em>self</em> number of gibibytes.
+	#
+	# :method: gib
+	
+	
+	
+	##
+	# :call-seq:
+	#   tib  ->  bytesize
+	#
+	# Returns a new instance of {IECByteSize}[IECByteSize.html] representing <em>self</em> number of tebibytes.
+	#
+	# :method: tib
+	
+	
+	
+	##
+	# :call-seq:
+	#   pib  ->  bytesize
+	#
+	# Returns a new instance of {IECByteSize}[IECByteSize.html] representing <em>self</em> number of pebibytes.
+	#
+	# :method: pib
+	
+	
+	
+	##
+	# :call-seq:
+	#   eib  ->  bytesize
+	#
+	# Returns a new instance of {IECByteSize}[IECByteSize.html] representing <em>self</em> number of exbibytes.
+	#
+	# :method: eib
+	
+	
+	
+	##
+	# :call-seq:
+	#   zib  ->  bytesize
+	#
+	# Returns a new instance of {IECByteSize}[IECByteSize.html] representing <em>self</em> number of zebibytes.
+	#
+	# :method: zib
+	
+	
+	
+	##
+	# :call-seq:
+	#   yib  ->  bytesize
+	#
+	# Returns a new instance of {IECByteSize}[IECByteSize.html] representing <em>self</em> number of yobibytes.
+	#
+	# :method: yib
+	
+	
+	
+end

data/lib/bytesize/version.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby -w
+#
+# ByteSize
+#
+# version.rb
+#
+# © 2018 Adam Hunt
+# Created: 2018-03-24
+# Modified: 2018-03-24
+#
+
+
+
+class ByteSize
+	VERSION = "0.1.0".freeze
+end
+
+

data/spec/bytesize_spec.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby -w
+#
+# ByteSize
+#
+# Spec
+#
+# © 2018 Adam Hunt
+# Created: 2018-04-07
+# Modified: 2018-04-07
+#
+
+
+
+require 'rspec'
+require 'test_enum'
+require 'shared_examples'
+
+require 'bytesize'
+
+
+
+describe ByteSize do
+	TestEnum.new( base:1000 ).each do |value|
+
+		it_behaves_like "a byte size", value
+
+		#include_examples "compares to an instance of equal value correctly", new_class:IECByteSize
+
+	end
+end

data/spec/iecbytesize_spec.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby -w
+#
+# ByteSize
+#
+# Spec
+#
+# © 2018 Adam Hunt
+# Created: 2018-04-07
+# Modified: 2018-04-07
+#
+
+
+
+require 'rspec'
+require 'test_enum'
+require 'shared_examples'
+
+require 'bytesize'
+
+
+
+describe IECByteSize do
+	TestEnum.new( base:1024 ).each do |value|
+
+		include_examples "a byte size", value
+
+		#include_examples "compares to an instance of equal value correctly", new_class:ByteSize
+
+	end
+end

data/spec/shared_examples.rb

@@ -0,0 +1,408 @@
+#!/usr/bin/env ruby -w
+#
+# ByteSize
+#
+# Shared Examples
+#
+# © 2018 Adam Hunt
+# Created: 2018-04-07
+# Modified: 2018-04-07
+#
+
+
+
+require 'value_class_helper'
+
+
+
+shared_examples "a byte size" do |value|
+	context "and" do
+
+		let(:instance){ described_class.new(value) }
+
+		let(:i){ instance.to_i }
+
+
+		###
+		# Initialization
+		###
+
+		context "initialized from an integer" do
+			it "returns an instance of the correct class" do
+				expect(instance.class).to be(described_class)
+			end
+			it "stores and returns the correct value" do
+				expect(i).to eq(value)
+			end
+		end
+
+
+		###
+		# Type Conversion
+		###
+
+		describe "#to_i" do
+			it "returns an integer" do
+				expect(i.class).to be(Integer)
+			end
+		end
+
+
+		###
+		# Unit Conversion
+		###
+
+		describe "#bytes" do
+			let(:v){ instance.bytes }
+			it "returns the correct value in bytes" do
+				expect(v).to eq(value)
+			end
+			it "returns an integer" do
+				expect(v.class).to eq(Integer)
+			end
+		end
+
+		describe "#to_bytes" do
+			let(:v){ instance.to_bytes }
+			it "returns the correct value in bytes" do
+				expect(v).to eq(value)
+			end
+			it "returns an integer" do
+				expect(v.class).to eq(Integer)
+			end
+		end
+
+		describe "#to_kb" do
+			let(:v){ instance.to_kb }
+			it "returns the correct value in kilobytes" do
+				expect(v).to be( value.to_f / 1000 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_kib" do
+			let(:v){ instance.to_kib }
+			it "returns the correct value in kibibyte" do
+				expect(v).to be( value.to_f / 1024 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_mb" do
+			let(:v){ instance.to_mb }
+			it "returns the correct value in megabytes" do
+				expect(v).to be( value.to_f / 1000000 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_mib" do
+			let(:v){ instance.to_mib }
+			it "returns the correct value in mebibytes" do
+				expect(v).to be( value.to_f / 1048576 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_gb" do
+			let(:v){ instance.to_gb }
+			it "returns the correct value in gigabytes" do
+				expect(v).to be( value.to_f / 1000000000 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_gib" do
+			let(:v){ instance.to_gib }
+			it "returns the correct value in gibibytes" do
+				expect(v).to be( value.to_f / 1073741824 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_tb" do
+			let(:v){ instance.to_tb }
+			it "returns the correct value in terabytes" do
+				expect(v).to be( value.to_f / 1000000000000 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_tib" do
+			let(:v){ instance.to_tib }
+			it "returns the correct value in tebibytes" do
+				expect(v).to be( value.to_f / 1099511627776 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_pb" do
+			let(:v){ instance.to_pb }
+			it "returns the correct value in petabytes" do
+				expect(v).to be( value.to_f / 1000000000000000 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_pib" do
+			let(:v){ instance.to_pib }
+			it "returns the correct value in pebibytes" do
+				expect(v).to be( value.to_f / 1125899906842624 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_eb" do
+			let(:v){ instance.to_eb }
+			it "returns the correct value in exabytes" do
+				expect(v).to be( value.to_f / 1000000000000000000 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_eib" do
+			let(:v){ instance.to_eib }
+			it "returns the correct value in exbibytes" do
+				expect(v).to be( value.to_f / 1152921504606846976 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_zb" do
+			let(:v){ instance.to_zb }
+			it "returns the correct value in zettabytes" do
+				expect(v).to be( value.to_f / 1000000000000000000000 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_zib" do
+			let(:v){ instance.to_zib }
+			it "returns the correct value in zebibytes" do
+				expect(v).to be( value.to_f / 1180591620717411303424 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_yb" do
+			let(:v){ instance.to_yb }
+			it "returns the correct value in yottabytes" do
+				expect(v).to be( value.to_f / 1000000000000000000000000 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+		describe "#to_yib" do
+			let(:v){ instance.to_yib }
+			it "returns the correct value in yobibytes" do
+				expect(v).to be( value.to_f / 1208925819614629174706176 )
+			end
+			it "returns an float" do
+				expect(v.class).to eq(Float)
+			end
+		end
+
+
+		###
+		# Comparison
+		###
+
+		include_examples "compares to itself correctly"
+
+		include_examples "compares to a duplicate instance correctly"
+
+		include_examples "compares to an instance of equal value correctly"
+
+		#include_examples "compares to an equal numeric correctly", value:value.to_i
+
+		#include_examples "compares to an equal numeric correctly", value:value.to_r
+
+		#include_examples "compares to an equal float correctly", value
+
+		#larger_value = rand(value+1..1024**9)
+
+		#include_examples "compares to a larger numeric correctly", value, larger_value.to_i
+
+		#include_examples "compares to a larger numeric correctly", value, larger_value.to_r
+
+		#include_examples "compares to a larger float correctly", value, larger_value
+
+
+
+
+
+
+
+
+
+
+		# larger_value = rand(value+1..1024**9)
+
+		# context "when compared to a larger instance (#{larger_value} bytes)" do
+		# 	let(:a){ instance }
+		# 	let(:b){ described_class.new(larger_value) }
+		# 	include_examples "correct comparison", {
+		# 		:==     => false,
+		# 		:===    => false,
+		# 		:eql?   => false,
+		# 		:equal? => false,
+		# 		:<=>    => -1,
+		# 		:>      => false,
+		# 		:<      => true,
+		# 		:>=     => false,
+		# 		:<=     => true
+		# 	}
+		# end
+
+		# context "when a larger instance (#{larger_value} bytes) is compared to it" do
+		# 	let(:a){ described_class.new(larger_value) }
+		# 	let(:b){ instance }
+		# 	include_examples "correct comparison", {
+		# 		:==     => false,
+		# 		:===    => false,
+		# 		:eql?   => false,
+		# 		:equal? => false,
+		# 		:<=>    => 1,
+		# 		:>      => true,
+		# 		:<      => false,
+		# 		:>=     => true,
+		# 		:<=     => false
+		# 	}
+		# end
+
+		# context "when compared to a larger integer (#{larger_value.to_i})" do
+		# 	let(:a){ instance }
+		# 	let(:b){ larger_value.to_i }
+		# 	include_examples "correct comparison", {
+		# 		:==     => false,
+		# 		:===    => false,
+		# 		:eql?   => false,
+		# 		:equal? => false,
+		# 		:<=>    => -1,
+		# 		:>      => false,
+		# 		:<      => true,
+		# 		:>=     => false,
+		# 		:<=     => true
+		# 	}
+		# end
+
+		# context "when a larger integer (#{larger_value.to_i}) is compared to it" do
+		# 	let(:a){ larger_value.to_i }
+		# 	let(:b){ instance }
+		# 	include_examples "correct comparison", {
+		# 		:==     => false,
+		# 		:===    => false,
+		# 		:eql?   => false,
+		# 		:equal? => false,
+		# 		:<=>    => 1,
+		# 		:>      => true,
+		# 		:<      => false,
+		# 		:>=     => true,
+		# 		:<=     => false
+		# 	}
+		# end
+
+		# f = value.to_f
+		# context "when compared to a larger float (#{f})" do
+		# 	rounding_error_direction = f <=> value.to_i
+		# 	let(:a){ instance }
+		# 	let(:b){ f }
+		# 	include_examples "correct comparison", {
+		# 		:==     => rounding_error_direction.zero?,
+		# 		:===    => rounding_error_direction.zero?,
+		# 		:eql?   => false,
+		# 		:equal? => false,
+		# 		:<=>    => -rounding_error_direction,
+		# 		:>      => false,
+		# 		:<      => true,
+		# 		:>=     => ( rounding_error.zero? or rounding_error.positive? ),
+		# 		:<=     => ( rounding_error.zero? or rounding_error.negative? )
+		# 	}
+		# end
+
+		# context "when an equal float is compared to it" do
+		# 	f = value.to_f
+		# 	rounding_error = value.to_i <=> value.to_f
+		# 	let(:a){ f }
+		# 	let(:b){ instance }
+		# 	include_examples "correct comparison", {
+		# 		:==     => rounding_error.zero?,
+		# 		:===    => rounding_error.zero?,
+		# 		:eql?   => false,
+		# 		:equal? => false,
+		# 		:<=>    => rounding_error,
+		# 		:>      => rounding_error.positive?,
+		# 		:<      => rounding_error.negative?,
+		# 		:>=     => ( rounding_error.zero? or rounding_error.positive? ),
+		# 		:<=     => ( rounding_error.zero? or rounding_error.negative? )
+		# 	}
+		# end
+
+		# context "when compared to an equal rational" do
+		# 	let(:a){ instance }
+		# 	let(:b){ value.to_r }
+		# 	include_examples "correct comparison", {
+		# 		:==     => true,
+		# 		:===    => true,
+		# 		:eql?   => false,
+		# 		:equal? => false,
+		# 		:<=>    => 0,
+		# 		:>      => false,
+		# 		:<      => false,
+		# 		:>=     => true,
+		# 		:<=     => true
+		# 	}
+		# end
+
+		# context "when an equal rational is compared to it" do
+		# 	let(:a){ value.to_r }
+		# 	let(:b){ instance }
+		# 	include_examples "correct comparison", {
+		# 		:==     => true,
+		# 		:===    => true,
+		# 		:eql?   => false,
+		# 		:equal? => false,
+		# 		:<=>    => 0,
+		# 		:>      => false,
+		# 		:<      => false,
+		# 		:>=     => true,
+		# 		:<=     => true
+		# 	}
+		# end
+
+
+
+		include_examples "correctly reports positive, negative, and zero", value
+
+	end
+end