bytesize 0.1.0

data/spec/test_enum.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby -w
+#
+# ByteSize
+#
+# TestEnum
+#
+# An enumerable class that generates integer test values that include a range around each
+# unit transition point and a random set of intervals in between.
+#
+# © 2018 Adam Hunt
+# Created: 2018-04-07
+# Modified: 2018-04-07
+#
+
+
+
+class TestEnum
+	include Enumerable
+
+	def initialize( base:, num_powers:8, transition_range:(-2..2), random_intervals:5, negative:true )
+		@base             = base.to_i
+		@num_powers       = num_powers.to_i
+
+		@transition_range = transition_range.is_a?(Range) ? transition_range.freeze : Range.new(*transition_range).freeze
+		if @transition_range.max.nil? then
+			@transition_range = Range( @transition_range.last, @transition_range.first ).freeze
+		end
+
+		@random_intervals = random_intervals.to_i
+		@negative         = !! negative
+	end
+
+	attr_reader :base, :num_powers, :transition_range, :random_intervals
+
+	def negative?; @negative; end
+
+	def each
+		return enum_for(:each) unless block_given?
+
+		(( negative? ? -num_powers : 0 )..num_powers).inject(nil) do |last, current|
+			current = current == 0 ? 0 : (base**current.abs) * ( current.negative? ? -1 : 1 )
+
+			unless last.nil? or transition_range.max.nil?
+				interval_range = (last+transition_range.max+1..current+transition_range.min-1)
+
+				unless interval_range.max.nil?
+					if interval_range.size <= random_intervals
+						interval_range.each do |i|
+							yield(i)
+						end
+					else
+						intervals = []
+						random_intervals.times do
+							begin
+								r = rand(interval_range)
+							end while intervals.include?(r)
+							intervals.push(r)
+						end
+						intervals.sort!
+						intervals.each do |i|
+							yield(i)
+						end
+					end
+				end
+
+			end
+
+			if negative? or current != 0
+				transition_range.each do |r|
+					yield( current + r )
+				end
+			else
+				if transition_range.max != 0
+					(0..transition_range.max).each do |r|
+						yield( current + r )
+					end
+				end
+			end
+
+			current
+		end
+
+		return nil
+	end
+
+end

data/spec/value_class_helper.rb

@@ -0,0 +1,363 @@
+#!/usr/bin/env ruby -w
+#
+# Value Classes Helper
+#
+# © 2018 Adam Hunt
+# Created: 2018-04-07
+# Modified: 2018-04-08
+#
+
+
+
+shared_examples "correct comparison" do |op_hash|
+	raise( TypeError, "expected #{Hash}, got #{op_hash.class}" ) unless op_hash.is_a?(Hash)
+
+	op_hash.each do |op,v|
+		describe "with \##{op}" do
+			it "returns #{v.inspect}" do
+				expect( a.send( op, b ) ).to be v
+			end
+		end
+	end
+
+end
+
+
+
+shared_examples "compares to itself correctly" do
+
+	context "when compared to itself" do
+		let(:a){ instance }
+		let(:b){ instance }
+		include_examples "correct comparison", {
+			:==     => true,
+			:===    => true,
+			:eql?   => true,
+			:equal? => true,
+			:<=>    => 0,
+			:>      => false,
+			:<      => false,
+			:>=     => true,
+			:<=     => true
+		}
+	end
+
+end
+
+
+
+shared_examples "compares to a duplicate instance correctly" do |reverse:true|
+
+	let(:other){ described_class.new(instance) }
+
+	context "when compared to a duplicate" do
+		let(:a){ instance }
+		let(:b){ other }
+		include_examples "correct comparison", {
+			:==     => true,
+			:===    => true,
+			:eql?   => true,
+			:equal? => false,
+			:<=>    => 0,
+			:>      => false,
+			:<      => false,
+			:>=     => true,
+			:<=     => true
+		}
+	end
+
+	if reverse
+		context "a duplicate is compared to it" do
+			let(:a){ other }
+			let(:b){ instance }
+			include_examples "correct comparison", {
+				:==     => true,
+				:===    => true,
+				:eql?   => true,
+				:equal? => false,
+				:<=>    => 0,
+				:>      => false,
+				:<      => false,
+				:>=     => true,
+				:<=     => true
+			}
+		end
+	end
+
+end
+
+
+
+shared_examples "compares to an instance of equal value correctly" do |new_class:nil, reverse:true, to_method:(:to_i)|
+
+	let(:num){ instance.send(to_method) }
+	
+	if new_class.nil?
+		cont = "when compared to an instance of equal value"
+		rcont = "an instance of equal value is compared to it"
+		let(:other){ described_class.new(num) }
+	else
+		cont = "when compared to an instance of #{new_class} of equal value"
+		rcont = "an instance of #{new_class} of equal value is compared to it"
+		let(:other){ new_class.new(num) }
+	end
+
+	context cont do
+		let(:a){ instance }
+		let(:b){ other }
+		include_examples "correct comparison", {
+			:==     => true,
+			:===    => true,
+			:eql?   => true,
+			:equal? => false,
+			:<=>    => 0,
+			:>      => false,
+			:<      => false,
+			:>=     => true,
+			:<=     => true
+		}
+	end
+
+	if reverse
+		context rcont do
+			let(:a){ other }
+			let(:b){ instance }
+			include_examples "correct comparison", {
+				:==     => true,
+				:===    => true,
+				:eql?   => true,
+				:equal? => false,
+				:<=>    => 0,
+				:>      => false,
+				:<      => false,
+				:>=     => true,
+				:<=     => true
+			}
+		end
+	end
+
+end
+
+
+
+shared_examples "compares to an equal numeric correctly" do |value:nil, reverse:true, to_method:(:to_i)|
+
+	let(:other) do
+		unless value.nil?
+			v = value
+			raise( StandardError, "comparison value must be a #{Numeric}" ) unless v.is_a?(Numeric)
+		else
+			v = instance.send(to_method)
+			raise( StandardError, "to_method did not return a #{Numeric}" ) unless v.is_a?(Numeric)
+		end
+		v
+	end
+
+	context "when compared to an equal numeric" do
+		let(:a){ instance }
+		let(:b){ other }
+		include_examples "correct comparison", {
+			:==     => true,
+			:===    => true,
+			:eql?   => false,
+			:equal? => false,
+			:<=>    => 0,
+			:>      => false,
+			:<      => false,
+			:>=     => true,
+			:<=     => true
+		}
+	end
+
+	if reverse
+		context "when an equal numeric is compared to it" do
+			let(:a){ other }
+			let(:b){ instance }
+			include_examples "correct comparison", {
+				:==     => true,
+				:===    => true,
+				:eql?   => false,
+				:equal? => false,
+				:<=>    => 0,
+				:>      => false,
+				:<      => false,
+				:>=     => true,
+				:<=     => true
+			}
+		end
+	end
+
+end
+
+
+
+shared_examples "compares to a larger numeric correctly" do |instance_value, num, reverse=true|
+
+	if num.is_a?(Float)
+		raise( NotImplimentedError, " use \"compares to an larger float correctly\" instead" )
+	end
+
+	context "when compared to a larger #{num.class}" do
+		let(:a){ instance }
+		let(:b){ num }
+		include_examples "correct comparison", {
+			:==     => false,
+			:===    => false,
+			:eql?   => false,
+			:equal? => false,
+			:<=>    => -1,
+			:>      => false,
+			:<      => true,
+			:>=     => false,
+			:<=     => true
+		}
+	end
+
+	if reverse
+		context "when an equal #{num.class} is compared to it" do
+			let(:a){ num }
+			let(:b){ instance }
+			include_examples "correct comparison", {
+				:==     => false,
+				:===    => false,
+				:eql?   => false,
+				:equal? => false,
+				:<=>    => 1,
+				:>      => true,
+				:<      => false,
+				:>=     => true,
+				:<=     => false
+			}
+		end
+	end
+
+end
+
+
+
+shared_examples "compares to an equal float correctly" do |instance_value, num, reverse=true|
+
+	f = num.to_f
+
+	rounding_error = ( f <=> num )
+
+	context "when compared to an equal #{f.class}" do
+		let(:a){ instance }
+		let(:b){ f }
+		include_examples "correct comparison", {
+			:==     => rounding_error.zero?,
+			:===    => rounding_error.zero?,
+			:eql?   => false,
+			:equal? => false,
+			:<=>    => -rounding_error,
+			:>      => rounding_error.negative?,
+			:<      => rounding_error.positive?,
+			:>=     => ( rounding_error.zero? or rounding_error.negative? ),
+			:<=     => ( rounding_error.zero? or rounding_error.positive? )
+		}
+	end
+
+	if reverse
+		context "when an equal #{f.class} is compared to it" do
+			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
+	end
+
+end
+
+
+
+shared_examples "compares to a larger float correctly" do |instance_value, num, reverse=true|
+
+	f = num.to_f
+
+	rounding_error = ( f <=> num )
+
+	rounding_error_collision = ( f <=> instance_value )
+
+	context "when compared to a larger #{f.class}" do
+		let(:a){ instance }
+		let(:b){ f }
+		include_examples "correct comparison", {
+			:==     => rounding_error_collision.zero?,
+			:===    => rounding_error_collision.zero?,
+			:eql?   => false,
+			:equal? => false,
+			:<=>    => -rounding_error_collision,
+			:>      => rounding_error_collision.negative?,
+			:<      => rounding_error_collision.positive?,
+			:>=     => ( rounding_error_collision.zero? or rounding_error_collision.positive? ),
+			:<=     => ( rounding_error_collision.zero? or rounding_error_collision.negative? )
+		}
+	end
+
+	if reverse
+		context "when a larger #{f.class} is compared to it" do
+			let(:a){ f }
+			let(:b){ instance }
+			include_examples "correct comparison", {
+				:==     => rounding_error_collision.zero?,
+				:===    => rounding_error_collision.zero?,
+				:eql?   => false,
+				:equal? => false,
+				:<=>    => rounding_error_collision,
+				:>      => rounding_error_collision.positive?,
+				:<      => rounding_error_collision.negative?,
+				:>=     => ( rounding_error_collision.zero? or rounding_error_collision.negative? ),
+				:<=     => ( rounding_error_collision.zero? or rounding_error_collision.positive? )
+			}
+		end
+	end
+
+end
+
+
+
+shared_examples "correctly reports positive, negative, and zero" do |value|
+
+	describe "#positive?" do
+		let(:v){ instance.positive? }
+		it "returns a boolean" do
+			expect(v).to be(true).or be(false)
+		end
+		expected_value = ( value.positive? )
+		it "returns #{expected_value.inspect}" do
+			expect(v).to be(expected_value)
+		end
+	end
+
+	describe "#negative?" do
+		let(:v){ instance.negative? }
+		it "returns a boolean" do
+			expect(v).to be(true).or be(false)
+		end
+		expected_value = ( value.negative? )
+		it "returns #{expected_value.inspect}" do
+			expect(v).to be(expected_value)
+		end
+	end
+
+	describe "#zero?" do
+		let(:v){ instance.zero? }
+		it "returns a boolean" do
+			expect(v).to be(true).or be(false)
+		end
+		expected_value = ( value.zero? )
+		it "returns #{expected_value.inspect}" do
+			expect(v).to be(expected_value)
+		end
+	end
+
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: bytesize
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Adam Hunt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: ByteSize is a simple Ruby object that stores a size in bytes, while providing
+  human-readible string output with apropriate SI or IEC suffixes. Ample convenience
+  methods are also supplied for quick shorthand.
+email: bytesize@adamhunt.name
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/bytesize.rb
+- lib/bytesize/activerecord.rb
+- lib/bytesize/units.rb
+- lib/bytesize/version.rb
+- spec/bytesize_spec.rb
+- spec/iecbytesize_spec.rb
+- spec/shared_examples.rb
+- spec/test_enum.rb
+- spec/value_class_helper.rb
+homepage: http://github.com/ajmihunt/bytesize
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: A simple Ruby object that stores a size in bytes, while providing human-readible
+  string output
+test_files:
+- spec/test_enum.rb
+- spec/value_class_helper.rb
+- spec/shared_examples.rb
+- spec/bytesize_spec.rb
+- spec/iecbytesize_spec.rb