vigilem-support 0.0.9

data/spec/vigilem/support/lazy_simple_delegator_spec.rb

@@ -0,0 +1,77 @@
+require 'vigilem/support/lazy_simple_delegator'
+
+describe Vigilem::Support::LazySimpleDelegator do
+  
+  class Dino
+    def rawr!
+      puts 'rawr!'
+    end
+  end
+  
+  context 'before __setobj__' do
+    it %q<won't error with nil argument on instantiation> do
+      expect { described_class.new() }.to_not raise_error
+    end
+  end
+  
+  subject { described_class.new() }
+  
+  let(:before___setobj___to_s) { subject.to_s }
+  
+  context 'after __setobj__' do
+    
+    let(:dino) { Dino.new }
+    
+    before(:each) do
+      subject.__setobj__(dino)
+    end
+    
+    it 'will not allow delegation to self' do
+      expect { subject.__setobj__(subject) }.to raise_error(ArgumentError, 'cannot delegate to self')
+    end
+    
+    it 'will have its own to_s unlike built in ruby delegate' do
+      expect(subject.to_s).to eql before___setobj___to_s
+    end
+    
+    it 'will have its own inspect unlike built in ruby delegate' do
+      expect(subject.inspect).not_to eql dino.inspect
+    end
+    
+    describe 'delegation' do
+      it 'will take on object methods' do
+        expect(subject).to respond_to :rawr!
+      end
+    end
+    
+    describe '#strict_eql=, #strict_eql?, #use_strict_eql' do
+      
+      context 'default behavior' do
+        it '#strict_eql?, defaults to false' do
+          expect(subject.strict_eql?).to be_falsey
+        end
+      end
+      
+      describe '#strict_eql=' do
+        it %q<#strict_eql?, is true compares a delegator's __getobj__.object_id's> do
+          subject.strict_eql = true
+          expect(subject.eql?(SimpleDelegator.new(dino))).to be_truthy
+        end
+        
+        it %q<#strict_eql?, is true compares a non Delegators object_id to this __getobj__.object_id> do
+          subject.strict_eql = true
+          expect(subject.eql?(dino)).to be_truthy
+        end
+      end
+      
+      describe '#use_strict_eql' do
+        it %q<#use_strict_eql, sets strict_eql? to true and returns self> do
+          expect(subject.use_strict_eql).to eql(subject) and
+            an_object_having_attributes(:strict_eql? => true)
+        end
+      end
+      
+    end
+    
+  end
+end

data/spec/vigilem/support/obj_space_spec.rb

@@ -0,0 +1,47 @@
+require 'vigilem/support/obj_space'
+
+describe Vigilem::Support::ObjSpace do
+  
+  class ObjSpaceHost
+    extend Vigilem::Support::ObjSpace
+  end
+  
+  class SubObjSpaceHost < ObjSpaceHost
+  end
+  
+  after(:each) do
+    ObjSpaceHost.all.replace([])
+    SubObjSpaceHost.all.replace([])
+  end
+  
+  describe '#all' do
+    it 'defaults to []' do
+      expect(ObjSpaceHost.all).to eql([])
+    end
+  end
+  
+  describe '#obj_register' do
+    it 'returns the obj registered' do
+      expect(ObjSpaceHost.obj_register('asdf')).to eql('asdf')
+    end
+    
+    it 'adds the obj to #all' do
+      ObjSpaceHost.obj_register('asdf')
+      expect(ObjSpaceHost.all).to include('asdf')
+    end
+  end
+  
+  context 'subclass' do
+    it %q<will add to the parent class #all> do
+      SubObjSpaceHost.obj_register('test')
+      expect(ObjSpaceHost.all).to include('test')
+    end
+    
+    it 'will not list the parent class objects' do
+      ObjSpaceHost.obj_register('asdf')
+      expect(SubObjSpaceHost.all).not_to include('asdf')
+    end
+    
+  end
+  
+end

data/spec/vigilem/support/sys_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+require 'vigilem/support/sys'
+
+describe Vigilem::Support::Sys do
+  describe '::sizeof' do
+    describe 'returns the size of a string variable format' do
+      Given 'ii' do
+        Then { expect(described_class.sizeof(given_value)).to eql(8) }
+      end
+      
+      it 'with number repeats' do
+        expect(described_class.sizeof('CCSI32C')).to eql(133)
+      end
+      
+      it 'with !' do
+        expect(described_class.sizeof('CCS!I32C')).to eql(133)
+      end
+    end
+  end
+end

data/spec/vigilem/support/system_spec.rb

@@ -0,0 +1,31 @@
+
+require 'vigilem/support/system'
+
+describe Vigilem::Support::System do
+  
+  describe '::`mask_name`' do
+    it 'will respond_to? :mac?' do
+      expect(described_class).to respond_to(:mac?)
+    end
+    
+    it 'will respond_to? :linux?' do
+      expect(described_class).to respond_to(:linux?)
+    end
+    
+    it 'will respond_to? :windows?' do
+      expect(described_class).to respond_to(:windows?)
+    end
+    
+    it 'will respond_to? :bsd?' do
+      expect(described_class).to respond_to(:bsd?)
+    end
+    
+    it 'will respond_to? :nix?' do
+      expect(described_class).to respond_to(:nix?)
+    end
+    
+    it 'will respond_to? :aix?' do
+      expect(described_class).to respond_to(:aix?)
+    end
+  end
+end

data/spec/vigilem/support/transmutable_hash_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+require 'vigilem/support/transmutable_hash'
+
+  # {:key1=>["a", "b", "c"], :key2=>["e", "f"], :key => "d" }
+  # {:key1=>["a", "b", "c"], :key2=>["d", "e", "f"]} becomes 
+  # {"a"=>:key1, "b"=>:key1, "c"=>:key1, "d"=>:key2, "e"=>:key2, "f"=>:key2 }
+  # it will have a different object_id, because technically its a different hash
+describe Vigilem::Support::TransmutableHash do
+  Given(:hash_map) { described_class.new({:key1 => %w(a b c), :key2 => %w(e f), :key => 'd' }, 'default') }
+  
+  Given(:dump_key_hash) { 
+                         {"keycode1"=>"Escape", ["shift", "keycode1"]=>"Escape", ["altgr", "keycode1"]=>"Escape", 
+                          ["shift", "altgr", "keycode1"]=>"Escape", ["control", "keycode1"]=>"Escape", 
+                          ["shift", "control", "keycode1"]=>"Escape", ["altgr", "control", "keycode1"]=>"Escape", 
+                          ["shift", "altgr", "control", "keycode1"]=>"Escape", ["alt", "keycode1"]=>"Meta_Escape", 
+                          ["shift","alt", "keycode1"]=>"Meta_Escape", ["altgr", "alt", "keycode1"]=>"Meta_Escape", 
+                          ["shift", "altgr", "alt", "keycode1"]=>"Meta_Escape", 
+                          ["control", "alt", "keycode1"]=>"Meta_Escape", ["shift", "control", "alt", "keycode1"]=>"Meta_Escape"
+                         } 
+                        }
+  
+  
+  describe '#invert' do
+    When(:result) { hash_map.invert }
+    
+    Then { result == { "a" => :key1, "b" => :key1, "c" => :key1, "d" => :key, "e" => :key2, "f" => :key2 } }
+    
+    Then { hash_map.send(:_invert_cache_) == result } 
+    
+  end
+  
+  describe '#invert!' do
+    Given(:original) { described_class.new({%w(this is a key) => :value, :key2=>["e", "f"], :key => "d"}) }
+    Given(:hsh) { described_class.new({%w(this is a key) => :value, :key2=>["e", "f"], :key => "d"}) }
+    
+    it 'updates inplace the inversion' do
+      hsh.invert!
+      expect(hsh).to eql(original.invert)
+      expect(hsh).not_to eql(original)
+    end
+     
+  end
+  
+  describe '::fuse_vaue' do
+    
+    it 'concats values to when keys match' do
+      hsh = {%w(this is a key) => :value, :key2=>["e", "f"], :key => "d"}
+      expect(described_class.fuse_value(hsh, :key, 'my_value')).to eql(
+        {["this", "is", "a", "key"]=>:value, :key2=>["e", "f"], :key=>["d", "my_value"]}
+      )
+    end
+    
+    it 'inserts arrays when keys match' do
+      hsh = {%w(this is a key) => :value, :key2=>["e", "f"], :key => "d"}
+      expect(described_class.fuse_value(hsh, :key2, ['my_value'])).to eql(
+        {["this", "is", "a", "key"]=>:value, :key2=>["e", "f", ['my_value']], :key=>"d"}
+      )
+    end
+    
+    it 'acts like merge' do
+      hsh = {%w(this is a key) => :value, :key2=>["e", "f"], :key => "d"}
+      expect(described_class.fuse_value(hsh, %w(my new key), 'my_value')).to eql(
+        {["this", "is", "a", "key"]=>:value, :key2=>["e", "f"], :key=>"d", ["my", "new", "key"]=>"my_value"}
+      )
+    end
+    
+    it 'acts like merge and wraps an array value' do
+      hsh = {%w(this is a key) => :value, :key2=>["e", "f"], :key => "d"}
+      expect(described_class.fuse_value(hsh, %w(my new key), ['my_value'])).to eql(
+        {["this", "is", "a", "key"]=>:value, :key2=>["e", "f"], :key=>"d", ["my", "new", "key"]=>[["my_value"]]}
+      )
+    end
+    
+  end
+  
+  describe '::transmute' do
+    
+    it 'inverts the hash and splits up array values into keys' do
+      hsh = described_class.transmute({:key => [1,2,3] })
+      expect(hsh).to eql({1 => :key, 2 => :key, 3 => :key })
+    end
+    
+    it 'inverts the hash and wraps Array keys to prevent split up' do
+      hsh = described_class.transmute(
+        {["this", "is", "a", "key"]=>:value, :key2=>["e", "f"], :key=>"d"}
+      )
+      
+      expect(hsh).to eql(
+        {:value=>[["this", "is", "a", "key"]], "e"=>:key2, "f"=>:key2, "d"=>:key}
+      )
+    end
+    
+    describe 'prevent invert!.invert from breaking down the hash' do
+      it 'prevents Array keys from being split up on invert' do
+        hsh = described_class.new(
+          {["this", "is", "a", "key"]=>:value, :key2=>["e", "f"], :key=>"d"}
+        )
+        expect(hsh.invert!.invert).to eql(
+          {["this", "is", "a", "key"]=>:value, :key2=>["e", "f"], :key=>"d"}
+        )
+      end
+    end
+  end
+
+  context 'setting default' do
+    
+    describe 'values' do
+      Given(:default_value) { 'default' }
+      
+      describe 'with #new(default_value),' do
+        When(:instantiated) { described_class.new(default_value) }
+        
+        Then { expect(instantiated.default).to eql default_value }
+        Then { expect(instantiated.invert_default).to eql default_value }
+      end
+      
+      describe 'with #default=,' do
+        When(:assigned_default) do
+          sbj = described_class.new
+          sbj.default = default_value
+          sbj
+        end
+        
+        Then { expect(assigned_default.default).to eql default_value }
+        Then { expect(assigned_default.invert_default).to eql nil }
+      end
+      
+      describe 'with #defaults=,' do
+        When(:assigned_defaults) do
+          sbj = described_class.new
+          sbj.defaults = default_value
+          sbj
+        end
+        
+        Then { expect(assigned_defaults.defaults).to eql [default_value, default_value] }
+      end
+      
+    end
+    
+    describe 'procs' do
+      let(:proc) { lambda {|h,k| h[k] = Hash.new() }  }
+      
+      describe 'with #new(&proc),' do
+        
+        When(:instantiated) { described_class.new(&proc) }
+        
+        Then { expect(instantiated.default_proc).to eql proc }
+        Then { expect(instantiated.invert_default_proc).to eql proc }
+      end
+      
+      describe 'with #default_proc=,' do
+        
+        When(:assigned_default_proc) do
+          sbj = described_class.new
+          sbj.default_proc = proc
+          sbj
+        end
+        
+        Then { expect(assigned_default_proc.default_proc).to eql proc }
+        Then { expect(assigned_default_proc.invert_default_proc).to eql nil }
+      end
+      
+      describe 'with #default_procs=,' do
+        When(:assigned_default_procs) do
+          sbj = described_class.new
+          sbj.default_procs = proc
+          sbj
+        end
+        
+        Then { expect(assigned_default_procs.default_procs).to eql [proc, proc] }
+      end
+    end
+  end
+end

data/spec/vigilem/support/utils_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+
+require 'vigilem/support/utils'
+
+describe Vigilem::Support::Utils do
+  
+  describe '::_offset_from_length' do
+    it 'returns the amount that len is over the size of object' do
+      expect(subject._offset_from_length('tests', 7)).to eql(2)
+    end
+    
+    it 'returns 0 if the len passed in is lower than obj.size' do
+      expect(subject._offset_from_length('tests', 3)).to eql(0)
+    end
+  end
+  
+  context 'ArrayAndStringUtils' do
+    
+    describe '#split_at' do
+      Given(:str) { 'asdfqwer' }
+      
+      When(:result) { subject.split_at(str, 3) }
+      
+      Then { result == ['asd', 'fqwer'] }
+    end
+    
+    describe '#split_on' do
+      
+      let(:str) { ['keycode   2', '=', 'U+0031', 'U+0021', 'U+0031', 'U+0031', 'VoidSymbol'] }
+      
+      it 'acts like String#split in which it removes the item split on' do
+        expect(subject.split_on(str, 1)).to eql([['keycode   2'], ['U+0031', 'U+0021', 'U+0031', 'U+0031', 'VoidSymbol']])
+      end
+    end
+    
+    describe '#offset!, #offset' do
+      
+      context 'String param' do
+        
+        Given(:str) { 'tests' }
+        Given(:orig_str) { str }
+        
+        context 'len < str' do
+          
+          describe '#offset!' do
+            When(:result) { subject.offset!(str, 2) }
+            
+            Then { result == ['te', 0] }
+            Then { str == 'sts' }
+          end
+          describe '#offset' do
+            When(:result) { subject.offset(str, 2) }
+            
+            Then { result == ['te', 0] }
+            Then { result.object_id != str.object_id }
+            Then { str == orig_str }
+          end
+        end
+        
+        context 'len > str' do
+          describe '#offset' do
+            When(:result) { subject.offset!(str, 7) }
+            
+            Then { result == ['tests', 2] }
+          end
+          describe '#offset' do
+            When(:result) { subject.offset(str, 7) }
+            
+            Then { result == ['tests', 2] }
+            Then { str == orig_str }
+          end
+        end
+        
+      end
+      
+      context 'Array param' do
+        
+        Given(:ary) { ['a', 'b', 'c', 'd'] }
+        Given(:orig_ary) { ary }
+        
+        context 'len < ary' do
+          describe '#offset!' do
+            When(:result) { subject.offset!(ary, 2) }
+          
+            Then { result == [['a', 'b'], 0] }
+          end
+          describe '#offset' do
+            When(:result) { subject.offset(ary, 2) }
+          
+            Then { result == [['a', 'b'], 0] }
+            Then { ary == orig_ary }
+          end
+        end
+        
+        context 'len > ary' do
+          describe '#offset!' do
+            When(:result) { subject.offset!(ary, 7) }
+            
+            Then { result == [['a', 'b', 'c', 'd'], 3] }
+          end
+          describe '#offset' do
+            When(:result) { subject.offset(ary, 7) }
+            
+            Then { result == [['a', 'b', 'c', 'd'], 3] }
+            Then { ary == orig_ary }
+          end
+        end
+        
+      end
+    end
+    
+    describe '#unwrap_ary' do
+      it 'pops the item off the array when there is only one item in it' do
+        expect(described_class.unwrap_ary([1])).to eql(1)
+      end
+      
+      it 'leaves the array as is if there is more than one item in it' do
+        expect(described_class.unwrap_ary([1,2,3])).to eql([1,2,3])
+      end
+    end
+    
+    describe '#in_ranged_array?' do
+      it 'is the number included in an array of ranged items' do
+        expect(described_class.in_ranged_array?([0..12, 17..21], 18)).to be_truthy
+      end
+      
+      it 'handles a mixed array of Integer and ranges' do
+        expect(described_class.in_ranged_array?([0..12, 17, 19, 21], 19)).to be_truthy
+      end
+    end
+    
+  end
+  
+  context 'NumericUtils' do
+    
+    describe '#clamp' do
+      it 'returns the lower bounds if lower than it' do
+        expect(subject.clamp(-12, min: 0)).to eql(0)
+      end
+      
+      it 'returns the upper bounds if greater than it' do
+        expect(subject.clamp(15, max: 12)).to eql(12)
+      end
+      
+      it 'returns the variable given in if between the limits' do
+        expect(subject.clamp(5, min: 3, max: 12)).to eql(5)
+      end
+    end
+    
+    describe '#ceil_div' do
+      Given(:num) { 10 }
+      Given(:denom) { 7 }
+      
+      When(:result) { subject.ceil_div(num, denom) }
+      
+      Then { result == 2 }
+    end
+  end
+  
+  # @todo
+  describe 'GemUtils' do
+    
+    describe '::data_dir' do
+    
+    end
+    
+    describe '::gem_path' do
+    
+    end
+    
+  end
+  
+  describe 'KernelUtils' do
+    
+    describe '#get_class' do
+      
+      before(:all) { TempClass = Class.new }
+      
+      it 'will return the objects class' do
+        expect(described_class.get_class(TempClass.new)).to eql(TempClass)
+      end
+      
+      it 'will the Class if given one' do
+        expect(described_class.get_class(TempClass)).to eql(TempClass)
+      end
+    end
+    
+    describe '#send_all_or_no_args' do
+      it %q<won't send any arguments if the arity == 0> do
+        str = 'test'
+        expect(described_class.send_all_or_no_args(str.method(:to_s), 'hmm', 'this shouldn\'t do anything')).to eql(str)
+      end
+    end
+  end
+  
+  describe 'ObjectUtils' do
+    describe '#_deep_dup' do
+      
+    end
+    
+    describe '#deep_dup' do
+      
+    end
+    
+    describe '#inspect_id' do
+      
+    end
+    
+    describe '#inspect_shell' do
+      
+    end
+  end
+  
+end