vigilem-core 0.0.9

data/spec/vigilem/core/adapters/buffered_adapter_spec.rb

@@ -0,0 +1,16 @@
+require 'vigilem/core/adapters/buffered_adapter'
+
+describe Vigilem::Core::Adapters::BufferedAdapter do
+  
+  it 'is a BufferHandler' do
+    expect(described_class).to be < Vigilem::Core::BufferHandler
+  end
+  
+  describe '#initialize_buffered' do
+    it %q<init's a buffer_handler and adapter> do
+      pending('@todo test')
+      raise 'NotImplementedError'
+    end
+  end
+  
+end

data/spec/vigilem/core/buffer_handler_spec.rb

@@ -0,0 +1,51 @@
+require 'vigilem/core/buffer_handler'
+
+# @TODO finish
+describe Vigilem::Core::BufferHandler do
+  
+  before :all do
+    FakeBHandler = Class.new do 
+      include Vigilem::Core::BufferHandler
+      def initialize
+        initialize_buffer_handler
+      end
+    end
+  end
+  
+  subject do
+    FakeBHandler.new
+  end
+  
+  describe '#initialize_buffer_handler' do
+    
+    it 'will initialize the default buffer' do
+      expect(subject.buffers[:default]).not_to be_nil
+    end
+  end
+  
+  describe '#buffer' do
+    it 'returns a buffer' do
+      expect(subject.buffer).not_to be_nil
+      #alias_method :inbox, :buffer
+    end
+    it 'assigns a new Buffer of type passed in' do
+      subject.buffers[:default] = nil
+      subject.buffer(:default, '')
+      expect(subject.buffer).to be == Vigilem::Core::DefaultBuffer.new('')
+    end
+  end
+  
+  describe '#buffered' do
+    #@todo
+  end
+  
+  describe '#buffered!' do
+    #@todo
+  end
+  
+  context 'private' do
+    describe '#buffer=' do
+      #alias_method :inbox=, :buffer=
+    end
+  end
+end

data/spec/vigilem/core/buffer_spec.rb

@@ -0,0 +1,236 @@
+require 'vigilem/core/buffer'
+
+require 'delegate'
+
+describe Vigilem::Core::Buffer do
+  
+  
+  context 'private' do
+    
+    before :all do
+      SuperCheck = Class.new(String) { include ::Vigilem::Core::Buffer }
+    end
+    
+    before :all do
+      SuperDelegateCheck = Class.new(SimpleDelegator) { include ::Vigilem::Core::Buffer }
+    end
+    
+    subject { SuperCheck.new('abcdef') }
+    
+    describe '_super_check' do
+      it 'will call the superclass method if it exists' do
+        expect(subject.send(:_super_check, :slice, nil, 1,2)).to eql('bc')
+      end
+      
+      it %Q(will call the otherwise block if the superclass doesn't have the method) do
+        expect(subject.send(:_super_check, :dice, nil, 1,2) { '$' }).to eql('$')
+      end
+      
+      context 'delegate' do 
+        subject do
+          SuperDelegateCheck.new(%Q(ces't cheese))
+        end
+        
+        it 'will call __getobj__ if the class responds to it' do
+          expect(subject.send(:_super_check, :slice, nil, 7,2)).to eql('he')
+        end
+      end
+      
+    end
+  end
+  
+  class StrBuffer
+    include ::Vigilem::Core::Buffer
+    
+    def initialize(str=nil)
+      @str = str || 'I am rawrg!'
+    end
+    
+    def _dump(level)
+      Marshal.dump(@ary)
+    end
+    
+    def self._load(str)
+      self.new(*Marshal.load(str))
+    end
+    
+    def slice!(*args)
+      self.class.new(*@str.slice!(*args))
+    end
+    
+    def concat(other_str)
+      self.class.new(*@str.concat(other_str))
+    end
+    
+    def ==(other_obj)
+      @str == other_obj.instance_variable_get(:@str)
+    end
+    
+    def length
+      @str.length
+    end
+  end
+  
+  class AryBuffer
+    include ::Vigilem::Core::Buffer
+    
+    def initialize(*ary)
+      @ary = if ary.empty? then %w(a b c d) else ary end
+    end
+    
+    def _dump(level)
+      Marshal.dump(@ary)
+    end
+    
+    def self._load(str)
+      self.new(*Marshal.load(str))
+    end
+    
+    def slice!(*args)
+      self.class.new(*@ary.slice!(*args))
+    end
+    
+    def concat(other_str)
+      self.class.new(*@ary.concat(other_str))
+    end
+    
+    def ==(other_obj)
+      @ary == other_obj.instance_variable_get(:@ary)
+    end
+    
+    def length
+      @ary.length
+    end
+  end
+  
+  class FailBuffer
+    include ::Vigilem::Core::Buffer
+    def _dump(level)
+      Marshal.dump(@ary)
+    end
+    
+    def self._load(str)
+      self.new(*Marshal.dump(str))
+    end
+    
+    def initialize
+      @str = %w(a b c d)
+    end
+    
+    def concat(other_str)
+      @str.concat(other_str)
+    end
+  end
+  
+  describe '#offset!' do
+    context 'will slice! from the @input_buffer and return the remainder' do
+      
+      context StrBuffer do 
+        it 'buffer > len' do
+          expect(subject.offset!(4)).to be == [described_class.new('I am'), 0]
+        end
+        it 'buffer < len' do
+          expect(subject.offset!(13)).to be == [described_class.new('I am rawrg!'), 2]
+        end
+      end
+      context AryBuffer do
+        it 'buffer > len' do
+          expect(subject.offset!(3)).to be == [described_class.new('a', 'b', 'c'), 0]
+        end
+        
+        it 'buffer < len' do
+          expect(subject.offset!(9)).to be == [described_class.new('a', 'b', 'c', 'd'), 5]
+        end
+      end
+      
+    end
+  end
+  
+  shared_examples 'modifier!' do 
+    before(:all) { @buffer = described_class.new }
+      
+    let(:result) { @buffer.send(method_name, *args) }
+    
+    it 'return a subset of the original' do
+      expect(result).to be == described_class.new(*result_match)
+    end
+    
+    it 'will modify the original buffer' do
+      expect(@buffer).to be == described_class.new(*buffer_state)
+    end
+  end
+  
+  shared_examples 'modifier' do 
+    before(:all) { @buffer = described_class.new }
+    
+    let(:result) { @buffer.send(method_name, *args) }
+    
+    it 'return a subset of the original' do
+      expect(result).to be == described_class.new(*result_match)
+    end
+    
+    it 'will not effect the original buffer' do
+      expect(@buffer).to be == described_class.new(*buffer_state)
+    end
+  end
+  
+  describe '#slice' do
+    context AryBuffer do
+      it_behaves_like 'modifier' do
+        let(:method_name) { :slice }
+        let(:args) { [1, 2] }
+        let(:result_match) { %w(b c) }
+        let(:buffer_state) { %w(a b c d) }
+      end
+    end
+    
+    context StrBuffer do
+      it_behaves_like 'modifier' do
+        let(:method_name) { :slice }
+        let(:args) { [1, 2] }
+        let(:result_match) { ' a' }
+        let(:buffer_state) { 'I am rawrg!' }
+      end
+    end
+  end
+  
+  describe '#slice!' do
+    context AryBuffer do
+      it_behaves_like 'modifier!' do
+        let(:method_name) { :slice! }
+        let(:args) { [1, 2] }
+        let(:result_match) { %w(b c) }
+        let(:buffer_state) { %w(a d) }
+      end
+    end
+    
+    context StrBuffer do
+      it_behaves_like 'modifier!' do
+        let(:method_name) { :slice! }
+        let(:args) { [1, 2] }
+        let(:result_match) { ' a' }
+        let(:buffer_state) { 'Im rawrg!' }
+      end
+    end
+  end
+  
+  describe 'concat' do
+    context AryBuffer do
+      it_behaves_like 'modifier!' do
+        let(:method_name) { :concat }
+        let(:args) { [[1]] }
+        let(:result_match) { %w(a b c d) + [1] }
+        let(:buffer_state) { %w(a b c d) + [1] }
+      end
+    end
+    
+    context StrBuffer do
+      it_behaves_like 'modifier!' do
+        let(:method_name) { :concat }
+        let(:args) { 'E>' }
+        let(:result_match) { 'I am rawrg!E>' }
+        let(:buffer_state) { 'I am rawrg!E>' }
+      end
+    end
+  end
+end

data/spec/vigilem/core/default_buffer_spec.rb

@@ -0,0 +1,17 @@
+require 'vigilem/core/default_buffer'
+
+describe Vigilem::Core::DefaultBuffer do
+  context 'declared type' do
+    describe '::wrap' do
+      it 'becomes the type passed in' do
+        expect(described_class.wrap('').__getobj__).to be_a(String)
+      end
+    end
+  end
+  
+  context 'default type ([])' do
+    it 'defaults the type to an array' do
+      expect(described_class.new.__getobj__).to be_an(Array)
+    end
+  end
+end

data/spec/vigilem/core/demultiplexer_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+require 'tempfile'
+
+require 'vigilem/core/demultiplexer'
+
+describe Vigilem::Core::Demultiplexer do
+  
+  after(:each) do
+    (described_class.instance_variables).each do |ivar| 
+        described_class.send(:remove_instance_variable, ivar)
+    end
+  end
+  
+  class OutEvent < Struct.new(:metadata, :type); end
+  
+  let(:outputs) { [[[], {:func => :concat}], [[], {:func => :concat}], [[], {:func => :concat}]] }
+  
+  let(:input) { [] }
+  
+  let(:device_one) do 
+    t = Tempfile.new('dev')
+    def t.name
+      'at keyboard'
+    end
+    t
+  end
+  
+  let(:device_two) do 
+    t = Tempfile.new('dev2')
+    def t.name
+      'wheel mouse'
+    end
+    t
+  end
+  
+  let(:devices) { [device_one, device_two] }
+  
+  let(:events) do
+    [
+      OutEvent.new({:source => devices.first}),
+      OutEvent.new({:source => devices.last}),
+      OutEvent.new({}, 1),
+      OutEvent.new({}, 2)
+    ] 
+  end
+  
+  context 'class-level' do
+    
+    describe '#option_names' do
+      it 'returns a list of options for this observer' do
+        expect(described_class.option_names).to all(be_a(Symbol))
+      end
+    end
+    
+    describe '#event_option_names' do
+      it 'returns the event option Symbols' do
+        good_opt = described_class.event_option_names
+        expect(described_class.event_option_names).to all(be_a(Symbol)) and not include(:func)
+      end
+    end
+    
+    describe '::all' do
+      it 'defaults to []' do
+        expect(described_class.all).to be_empty
+      end
+    end
+    
+    describe '::filter_events' do
+      
+      it 'filters events if the device is the same as an event source' do
+        expect(described_class.filter_events(events, {:device => device_one })).to eql(events.take(1))
+      end
+      
+      it 'filters events if a device is the same as an event source' do
+        expect(described_class.filter_events(events, {:devices => devices })).to eql(events.take(2))
+      end
+      
+      it 'filters events if the Regexp matches an event source name' do
+        expect(described_class.filter_events(events, {:device_name => /keyboard/ })).to eql(events.take(1))
+      end
+      
+      it 'filters events if a Regexp matches an event source name' do
+        expect(described_class.filter_events(events, {:device_names => [/keyboard/, /mouse/] })).to eql(events.take(2))
+      end
+      
+      it 'filters events if the type is the same as an event type' do
+        expect(described_class.filter_events(events, {:type => 1 })).to eql([events[2]])
+      end
+      
+      it 'filters events if a type is the same as an event type' do
+        expect(described_class.filter_events(events, {:types => [1, 2] })).to eql(events[2,2])
+      end
+    end
+    
+  end
+  
+  describe '#filter_events' do
+    it 'calls the clas level filter events' do
+      allow(described_class).to receive(:filter_events)
+      expect(described_class).to receive(:filter_events)
+      subject.filter_events([], {})
+    end
+  end
+  
+  describe '#outputs' do
+    it 'starts empty' do
+      expect(subject.outputs).to be_empty
+    end
+  end
+  
+  describe '#input' do
+    it 'starts empty' do
+      expect(subject.input).to be_nil
+    end
+  end
+  
+  describe '#add_observer' do
+    
+    it 'returns the opts args passed in (like Observerable)' do
+      expect(subject.add_observer(*outputs.first)).to eql(outputs.first.last)
+    end
+    
+    it 'adds to #ouputs' do
+      subject.add_observer(*outputs.first)
+      expect(subject.outputs).to be == outputs.first.take(1)
+    end
+  end
+  
+  describe '#initialize' do
+    
+    subject { described_class.new(input, outputs) }
+    
+    it 'sets #outputs' do
+      expect(subject.outputs).to eql(outputs.map(&:first))
+    end
+    
+    it 'sets #input' do
+      expect(subject.input).to eql(input)
+    end
+    
+    it 'adds it to #all' do
+      expect(described_class.all).to eql([subject])
+    end
+    
+  end
+  
+  describe '#notify_observers' do
+    it 'pushes passed in events to observers' do
+      arg = described_class.new(input, outputs)
+      arg.changed
+      arg.notify_observers(*events)
+      expect(outputs.flat_map(&:first)).not_to be_empty
+    end
+  end
+  
+  describe '#demux' do
+    it 'pulls from the input and pushes to the correct observers' do
+      arg = described_class.new(input, outputs)
+      (arg.input ||= []) << events.first
+      arg.demux
+      expect(outputs.flat_map(&:first)).to all(be_a(OutEvent))
+    end
+  end
+  
+end