vigilem-core 0.0.9

data/spec/vigilem/core/device_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+require 'vigilem/core/device'
+
+describe Vigilem::Core::Device do
+  describe '#new' do
+    
+    Stat = Vigilem::Core::Stat
+    
+    before(:each) do
+      Stat.all << double('fake_stat', :available? => true, :input_system_name => 'guy on the couch')
+    end
+    
+    after(:each) do
+      Stat.all.replace([])
+    end
+    
+    subject do
+      described_class.new do
+        on_os(/.+/) do
+          @adaptability_level = 'Tardigrade'
+        end
+        
+        on_input_system(/.+/) do
+          @mode = 'stun'
+        end
+        after_init { @testr = 'test' }
+      end
+    end
+    
+    context 'class creation' do
+      it 'creates a Class if block given' do
+        expect(subject).to be_instance_of(Class)
+      end
+    end
+    
+    context 'instantiation' do
+      
+      it 'throws error when settings are empty' do
+        expect { described_class.new }.to raise_error(RuntimeError)
+      end
+      
+      it 'will pass system_checks' do
+        expect { subject.new }.to_not raise_error
+      end
+      
+      context 'hooks' do
+        it 'runs #on_os hook' do
+          expect(subject.new.instance_variable_get(:@adaptability_level)).to eql 'Tardigrade'
+        end
+        
+        it 'runs #on_input_system hook' do
+          expect(subject.new.instance_variable_get(:@mode)).to eql 'stun'
+        end
+        
+      end
+    end
+    
+    
+  end
+  
+end

data/spec/vigilem/core/event_handler_spec.rb

@@ -0,0 +1,134 @@
+
+require 'vigilem/core/event_handler'
+
+describe Vigilem::Core::EventHandler do
+  
+  class EventHandlerHost
+    include Vigilem::Core::EventHandler
+  end
+  
+  subject { EventHandlerHost.new }
+  
+  describe '#type_handles' do
+    
+    it 'returns a Hash' do
+      expect(subject.type_handles).to be_a(Hash)
+    end
+  end
+  
+  context 'register, execution' do
+    
+    let(:handler) do 
+      lambda do |event|
+        ["I'm handling it", event]
+      end
+    end
+    
+    let!(:register) { subject.on(:my_event, &handler) }
+    
+    describe '#on' do
+      it 'adds a block to the hash with the key == type arg' do
+        expect(subject.type_handles[:my_event].call(:my_event)).to eql(handler.call(:my_event))
+      end
+      
+    end
+    
+    describe '#handle' do
+      
+      class Event 
+      end
+      
+      class UnknownEvent
+      end
+      
+      let(:event) do
+        Event.new
+      end
+      
+      let(:handler) do 
+        lambda do |event|
+          ["I'm handling it", event]
+        end
+      end
+      
+      it 'executes the registered block with the event as arg' do
+        subject.on(Event, &handler)
+        expect(subject.handle(event)).to eql(["I'm handling it", event])
+      end
+      
+      it 'returns nil when event is not registered/handle-able' do
+        subject.on(Event, &handler)
+        expect(subject.handle(UnknownEvent.new)).to be_nil
+      end
+    end
+    
+    let(:test_name) { 'on_test_event' }
+    
+    describe '#type_from_on_format' do
+      it 'strips out the event type from the on_#{event_type} format' do
+        expect(described_class.type_from_on_format(test_name)).to eql(:test_event)
+      end
+    end
+    
+    describe '::type_from_on_format' do
+      it 'returns whether or not the string is in on_#{event_type} format' do
+        expect(described_class.type_from_on_format(test_name)).to be_truthy
+      end
+    end
+    
+    describe '#respond_to?' do
+      it 'responds to items in the on_#{type} format' do
+        expect(described_class.respond_to?(test_name)).to be_truthy
+      end
+    end
+    
+    context 'private' do
+      
+      describe '_define_register' do
+        
+        it 'will not respond to direct access' do
+          expect { subject.class._define_register }.to raise_error(NoMethodError, /private method `_define_register'/)
+        end
+        
+        class SomeEvent; end
+        
+        let!(:run_method) { subject.class.send(:_define_register, SomeEvent, 'some_event') }
+        
+        it 'defines the class_method on_#{type} method' do
+          expect(subject.class).to respond_to(:on_some_event)
+        end
+        
+        it 'defines the instance_method on_#{type} method' do
+          expect(subject.class.method_defined?(:on_some_event)).to be_truthy
+        end
+        
+        it 'returns the method defined' do
+          expect(run_method).to be_a(Method)
+        end
+        
+      end
+      
+      describe '_define_handler' do
+        
+        it 'will not respond to direct access' do
+          expect { subject.class._define_handler }.to raise_error(NoMethodError, /private method `_define_handler'/)
+        end
+        
+        class SomeEvent; end
+        
+        let!(:run_method) { subject.class.send(:_define_handler, 'some_event') {|event| "this is some_event #{event}" } }
+        
+        it 'defines the instance_method on_#{type} method' do
+          expect(subject.class.method_defined?(:handle_some_event)).to be_truthy
+        end
+        
+        it 'returns the method defined' do
+          expect(run_method).to be_a(Proc)
+        end
+        
+      end
+    end #context 'private'
+    
+  end
+  
+end

data/spec/vigilem/core/hooks/callback_proc_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+require 'vigilem/core/hooks'
+
+describe Vigilem::Core::Hooks::CallbackProc do
+  subject do
+    described_class.new do
+      self
+    end
+  end
+  
+  describe '#evaluate' do
+    
+    before(:all) { Context = Class.new }
+    
+    context 'class' do
+      
+      let!(:result) { subject.evaluate(Context) }
+      
+      it 'will run in the class context specified' do
+        expect(result).to eql(Context)
+      end
+      
+      it '[] will be the same' do
+        expect(result).to eql(Context)
+      end
+      
+      it 'will remember the last result' do
+        expect(subject.result).to eql(Context)
+      end
+    end
+    
+    context 'instance' do
+      
+      let(:instance) { Context.new }
+      
+      let!(:result) { subject.evaluate(instance) }
+      
+      it 'will run in the object context specified' do
+        expect(result).to eql(instance)
+      end
+      
+      it '[] will be the same' do
+        expect(result).to eql(instance)
+      end
+      
+      it 'will remember the last result' do
+        expect(subject.result).to eql(instance)
+      end
+    end
+    
+  end
+  
+  describe '#call' do
+    
+    let!(:result) { subject.call }
+    
+    it 'will run like Proc' do
+      expect(result).to eql(self)
+    end
+    
+    it 'will remember the result' do
+      expect(subject.result).to eql(result)
+    end
+  end
+end

data/spec/vigilem/core/hooks/hook_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+
+require 'vigilem/core/hooks'
+
+describe Vigilem::Core::Hooks::Hook do
+  
+  subject { described_class.new(:testr) }
+  
+  describe '#new' do
+    
+    it 'to yield itself' do
+      expect {|b| described_class.new(:testr, &b).to yield_control }
+    end
+    
+  end
+  
+  context 'after initialized' do
+    
+    let!(:init_size) { subject.callbacks.size }
+    
+    describe '#<<' do
+      
+      let!(:callbacks) { subject << lambda { self } }
+      
+      it 'should increase callbacks by one' do
+        expect(subject.callbacks.size).to eql(init_size + 1)
+      end
+      
+      it 'will return a full the list of callbacks' do
+        expect(callbacks).to equal(subject.callbacks)
+      end
+      
+      it 'will convert procs to Callbacks' do
+        expect(callbacks.all? {|cb| cb.is_a? Vigilem::Core::Hooks::Callback }).to be_truthy
+      end
+    end
+    
+    describe '#add' do
+      let!(:callbacks) { subject.add { self } }
+      
+      it 'should increase callbacks by one' do
+        expect(subject.callbacks.size).to eql(init_size + 1)
+      end
+      
+      it 'will return a full the list of callbacks' do
+        expect(callbacks).to equal(subject.callbacks)
+      end
+      
+      it 'will convert procs to Callbacks' do
+        expect(callbacks.all? {|cb| cb.is_a? Vigilem::Core::Hooks::Callback }).to be_truthy
+      end
+    end
+    
+    describe '#callbacks' do
+      
+      let(:sub_callback) do 
+          class TmpSubClass < self.class
+            lambda { self }
+          end
+        end 
+      
+      let!(:all_callbacks) { subject << sub_callback }
+      
+      it 'filters out subclass callbacks when given context/scope' do
+        expect(subject.callbacks(self).none? {|cb| cb.source_location == sub_callback.source_location }).to be_truthy
+      end
+      
+    end
+    
+    context 'execution' do
+      
+      let!(:callback1) { subject.add { self }.last }
+        
+      let!(:callback2) { subject.add { self.class }.last }
+      
+      describe '#call' do
+        
+        it 'will execute callbacks in the context which they where created' do
+          expect(subject.call()).to eql([self, self.class])
+        end
+      end
+      
+      describe '#run' do
+        
+        let!(:context) { (FakeContext = Class.new).new }
+        
+        it 'will execute callbacks in the context which is passed in' do
+          expect(subject.run(context)).to eql([context, FakeContext])
+        end
+      end
+    end
+    
+    describe '#default_body' do
+      
+      it 'will return a Proc' do
+        expect(subject.default_body).to be_a(Proc)
+      end
+      
+    end
+    
+    describe '#bind' do
+    
+      let!(:context) do 
+          local = subject
+          Class.new do 
+            extend Vigilem::Core::Hooks
+            local.bind(self)
+          end 
+        end
+      
+      it 'will add hook as singleton_method' do
+        expect(context.respond_to?(:testr)).to be_truthy
+      end
+      
+      describe '#owner' do
+        it 'wil be the value of context' do
+          expect(subject.owner).to eql(context)
+        end
+      end
+      
+    end
+    
+    describe '#generate' do
+    
+      let!(:context) do
+          local = subject
+          Class.new do 
+            extend Vigilem::Core::Hooks
+            local.generate(self)
+          end.new
+        end
+      
+      it 'will add hook as instance_method' do
+        expect(context.respond_to?(:testr)).to be_truthy
+      end
+      
+      describe '#owner' do
+        it 'wil be the value of context' do
+          expect(subject.owner).to eql(context.class)
+        end
+      end
+      
+    end
+    
+    describe '#body' do
+      
+      it 'will return default_proc when not set' do
+        expect(subject.send(:body)).to equal(subject.default_body)
+      end
+      
+      let(:nw_body) { lambda { puts 'test' } }
+      
+      it 'will return a block when given one' do
+        expect(subject.send(:body, &nw_body)).to eql(nw_body)
+      end
+      
+      context 'generating' do
+        
+        subject do
+          described_class.new(:bdy) do
+            body { 'test' }
+          end
+        end
+        
+        let!(:context) do
+            local = subject
+            Class.new do 
+              extend Vigilem::Core::Hooks
+              local.generate(self)
+            end.new
+          end
+        
+        it 'will set the prco to be generated on the class' do
+          expect(context.bdy).to eql('test')
+        end
+        
+        context 'binding' do
+          subject do
+            described_class.new(:bdy) do
+              body { 'test' }
+            end
+          end
+          
+          let!(:context) do
+              local = subject
+              Class.new do 
+                extend Vigilem::Core::Hooks
+                local.bind(self)
+              end
+            end
+          
+          it 'will set the proc to be binded on the class' do
+            expect(context.bdy).to eql('test')
+          end
+        end
+        
+      end
+    end
+    
+    describe '::enumerate' do
+      
+      let(:call_backs) do 
+        [ Vigilem::Core::Hooks::CallbackProc.new {|arg| self }, 
+          Vigilem::Core::Hooks::CallbackProc.new {|arg| self.class } ]
+      end
+      
+      it 'will accept args with a list of callbacks and enumerate through them passing a long the args' do
+        expect(call_backs.first).to receive(:call).with('test').and_return('test')
+        expect(call_backs.last).to receive(:call).with('test').and_return(String)
+        described_class.send(:enumerate, call_backs, :args => 'test')
+      end
+      
+      it 'will return the results' do
+        expect(described_class.send(:enumerate, call_backs, :args => 'test')).to eql([self, self.class])
+      end
+      
+      it 'will accept a block and yield a meta_callback' do
+        expect {|b| described_class.send(:enumerate, call_backs, &b).to yield_with_args(MetaCallback) }
+      end
+      
+      it 'will accept an arg of :context and evaluate the callbacks in that context' do
+        expect(call_backs.first).to receive(:evaluate).with(self, 'test').and_return(self)
+        expect(call_backs.last).to receive(:evaluate).with(self, 'test').and_return(String)
+        described_class.send(:enumerate, call_backs, :context => self, :args => 'test')
+      end
+    end
+    
+    
+  end
+end