vigilem-core 0.0.9

data/lib/vigilem/core/stat.rb

@@ -0,0 +1,121 @@
+require 'vigilem/support/core_ext'
+
+require 'vigilem/support/obj_space'
+
+require 'vigilem/core/system'
+
+require 'rubygems/dependency_installer'
+
+module Vigilem
+module Core
+  # 
+  # Stat(us) of the input_system and the handler 
+  # gem associated with it
+  class Stat
+    attr_reader :platform_masks, :gem_name, :input_system_name
+    
+    attr_accessor :api_check
+    
+    private :api_check, :api_check=
+    
+    # @fixme  duplicates in ::all
+    # @param  [String] gem_name
+    # @param  [Hash] opts
+    # @param  [Proc] api_check
+    # @return 
+    def self.new(*args, &block)
+      obj_register(super(*args, &block))
+    end
+    
+    # 
+    # @param  [Array] args
+    # @param  [Proc] block
+    # @return [TrueClass || FalseClass]
+    def api_check?(*args, &block)
+      !!api_check.call(*args, &block)
+    end
+    
+    # 
+    # @param  [String] input_system, the descriptive name of the input_system
+    # @param  [String] gemname, the gem name of the handler to install
+    # @param  [Hash] opts
+    # @option opts [Array<Regexp || Symbol>] :platforms
+    # @option opts :requirement, defaults to Gem::Requirement.default
+    # @param  [Proc] api_check
+    # @return 
+    def initialize(input_system, gemname, opts={}, &api_check)
+      @input_system_name = input_system
+      @gem_name = gemname
+      @gem_requirement = opts[:requirement] ||= Gem::Requirement.default
+      
+      @platform_masks = [*opts[:platforms] || /.+/].map do |plats| 
+        if plats.is_a?(Symbol)
+          System::SYSTEM_NAME_MASKS[plats]
+        elsif plats.is_a?(Regexp)
+          plats
+        else
+          raise NotImplementedError, "UnSupported type #{plats.class}:#{plats}"
+        end
+      end
+      @api_check = api_check
+    end
+    
+    # 
+    # 
+    def gem_requirement
+      @gem_requirement ||= Gem::Requirement.default
+    end
+    
+    # whether or not this input_system is availble on given os
+    # @param  [String || Regexp] os
+    # @return [TrueClass || FalseClass]
+    def available_on?(os)
+      System.check[:os][Regexp.union(platform_masks), os]
+    end
+    
+    alias_method :is_available_on?, :available_on?
+    
+    # 
+    # @param  version_requirement, optional
+    # @return 
+    def install(version_requirement=nil)
+      @installed = installer.install(gem_name, *version_requirement)
+    end
+    
+    # 
+    # @return [TrueClass || FalseCLass]
+    def installed?
+      if @installed.nil?
+        @installed = Gem::Specification.find_all_by_name(gem_name, *gem_requirement).any?
+      else
+        @installed
+      end
+    end
+    
+    #   
+    # whether or not this input_system is avaialble on this system
+    # @return [TrueClass || FalseClass]
+    def available?
+      available_on?(System.os) and api_check?
+    end
+    
+    extend Support::ObjSpace
+    
+    class << self
+      # 
+      # @return [Array<Stat>]
+      def all_available
+        all.select(&:available?)
+      end
+      
+    end
+   private
+    
+    # 
+    # @return [Gem::DependencyInstaller]
+    def installer
+      @installer ||= Gem::DependencyInstaller.new
+    end
+  end
+end
+end

data/lib/vigilem/core/system.rb

@@ -0,0 +1,9 @@
+require 'vigilem/support/system'
+
+module Vigilem
+module Core
+  System = Vigilem::Support::System
+end
+end
+
+require 'vigilem/core/system/check'

data/lib/vigilem/core/system/check.rb

@@ -0,0 +1,33 @@
+require 'vigilem/core/stat'
+
+module Vigilem
+module Core
+  # 
+  # 
+  module System
+    
+    # common checks for os and input_system
+    # pass `check[:os][/win/]` and it will #=~ against `RbConfig::CONFIG['host_os']`
+    # pass a string and it uses #==
+    # for input_sysmte_handlers it #find's the input_system_handler with the name that #=~
+    # the argument or #== it
+    # @return (TruceClass || FalseClass) whether or not the check passed
+    def self.check
+      @checks ||= {
+          :os => lambda do |str_or_regex, os=nil|
+                  os ||= Support::System.os
+                  !!(str_or_regex.is_a?(Regexp) and 
+                    str_or_regex =~ os) or 
+                    (str_or_regex.to_s == os.to_s)
+                end,
+          :input_system => lambda do |name_or_regex|
+                  ((name_or_regex.is_a?(Regexp) and 
+                    (stats = Stat.all_available).find {|isys| isys.input_system_name =~ name_or_regex }) or
+                    (stats.find {|isys| isys.input_system_name.to_s == name_or_regex.to_s })
+                  )
+                end
+        }
+    end
+  end
+end
+end

data/lib/vigilem/core/transfer_agent.rb

@@ -0,0 +1,67 @@
+
+require 'forwardable'
+
+require 'vigilem/support/core_ext'
+
+require 'vigilem/support/obj_space'
+
+require 'vigilem/core/multiplexer'
+
+require 'vigilem/core/demultiplexer'
+
+module Vigilem
+module Core
+  # 
+  # facade for demultiplexer <-> multiplexer coupling
+  class TransferAgent
+    
+    extend Forwardable
+    
+    attr_reader :multiplexer, :demultiplexer
+    
+    def_delegators :demultiplexer, :add_observer, :add_observers, :outputs
+    
+    def_delegator :multiplexer, :add_inputs
+    
+    # 
+    # 
+    def self.new(*args)
+      obj_register(super(*args))
+    end
+
+    # sets the input on demultiplexer to the ouput of multiplexer
+    # if both are nil it sets it to an Array
+    # @param  [#input=, #demux]
+    # @param  [#out, #mux]
+    def initialize(demuxer, muxer)
+      @demultiplexer, @multiplexer = demuxer, muxer
+      if (junction = (din = demultiplexer.input) || (mout = multiplexer.out)).nil? or not mout.equal?(din)
+        @demultiplexer.input = @multiplexer.out = (junction || [])
+      end
+    end
+    
+    # checks 
+    # @param  [Integer] num_of_events, defaults to 1
+    # @return [NilClass]
+    def relay(num_of_events=1)
+      multiplexer.mux(num_of_events)
+      demultiplexer.demux(num_of_events)
+      nil
+    end
+    
+    extend Support::ObjSpace
+    
+    class << self
+      
+      # 
+      # @param  [Module]
+      # @return 
+      def inherited(base)
+        base.extend Support::ObjSpace
+      end
+      
+    end
+    
+  end
+end
+end

data/lib/vigilem/core/version.rb

@@ -0,0 +1,5 @@
+module Vigilem
+module Core
+  VERSION = '0.0.9'
+end
+end

data/spec/bug_notes.txt

@@ -0,0 +1,12 @@
+RangeError: bignum too big to convert into `long'/int
+ruby bug Issue #6127
+
+doesnt work on default ubuntu ruby 1.9.3p194 (2012-04-20 revision 35410) [x86_64-linux]
+
+https://bugs.launchpad.net/ubuntu/+source/ruby1.9.1/+bug/997150
+
+
+EVIOCGNAME 2164212998
+
+
+EVIOCGABS 

data/spec/given_helper.rb

@@ -0,0 +1,12 @@
+# defines a given that takes a block and argument so that the argument given can be used as the description and
+# retrieved by given_value, essentially making bad tests
+RSpec::Core::ExampleGroup.define_singleton_method(:given) do |arg, &example_group_block|
+  thread_data = RSpec.thread_local_metadata
+  ret = subclass(self, 'given', arg.to_s, &example_group_block).tap do |child|
+    children << child
+  end
+  ret.send(:define_method, :given_value) do
+    arg
+  end
+  ret.new
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler.setup
+
+require 'rspec/given'
+require 'given_helper'
+
+require 'vigilem/support/core_ext/debug_puts'

data/spec/vigilem/core/abstract_device_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+require 'vigilem/core/abstract_device'
+
+describe Vigilem::Core::AbstractDevice do
+  
+  describe '#setting?' do
+    describe 'will test whether or not the hook is a setting' do 
+      context 'Hook' do
+        let(:hook) { ::Vigilem::Core::Hooks::Hook.new('tmp') }
+        
+        let!(:callbacks) { hook << ::Vigilem::Core::Hooks::Callback.new { true }  }
+        
+        it 'will pass before ran' do
+          expect(subject.setting?(hook)).to be_truthy
+        end
+        
+        it 'will pass after ran' do
+          expect(subject.setting?(hook)).to be_truthy
+        end
+      end
+      
+      context 'ConditionalHook' do
+        context 'passes' do
+          let(:hook) do 
+            ::Vigilem::Core::Hooks::ConditionalHook.new('tmp') do
+              condition { true }
+            end
+          end
+          
+          let!(:callbacks) { hook << ::Vigilem::Core::Hooks::Callback.new { true }  }
+          
+          it 'will fail before ran' do
+            expect(subject.setting?(hook)).to be_falsey
+          end
+          
+          it 'will be a setting when condition passes' do
+            hook.call
+            expect(subject.setting?(hook)).to be_truthy
+          end
+        end
+        
+        context 'fails' do
+          let(:hook) do 
+            ::Vigilem::Core::Hooks::ConditionalHook.new('tmp') do
+              condition { false }
+            end
+          end
+          
+          let!(:callbacks) { hook << ::Vigilem::Core::Hooks::Callback.new { true }  }
+          
+          it 'will not be a setting when the condition fails' do
+            hook.call
+            expect(subject.setting?(hook)).to be_falsey
+          end
+        end
+        
+      end
+    end
+  end
+  
+  describe '#new' do
+    
+    it 'will have one init setting after_init' do
+      expect(described_class.new.settings.first.name).to eql(:after_init)
+    end
+    
+    context 'system checks' do
+      
+      it 'runs the system_check' do
+        expect_any_instance_of(described_class).to receive(:run_system_checks)
+        described_class.new
+      end
+      
+      it 'will add to settings when the check passes' do
+        hook = ::Vigilem::Core::Hooks::ConditionalHook.new(:on_always, 
+                             {:type => :system_check, :inheritable => false }) { condition { true } }
+        described_class.hooks << hook
+        hook << lambda { 'do something' }
+        abs = described_class.new
+        expect(abs.settings).to_not be_empty
+      end
+    end
+  end
+  
+  describe 'pipeline building' do
+    before :all do
+      class Cheese
+        def yarg?
+          puts 'yarg!'
+        end
+      end
+    end
+    context 'after_import' do
+      let(:cheese) { Cheese.new }
+      
+      it 'will set @delegate_sd_obj to the import arg' do
+        subject.import(cheese)
+        expect(subject.instance_variable_get(:@delegate_sd_obj)).to eql cheese
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'vigilem/core/adapters/adapter'
+
+describe Vigilem::Core::Adapters::Adapter do
+  
+  class Host
+    include Vigilem::Core::Adapters::Adapter
+    
+    def initialize(lnk=nil)
+      initialize_adapter(lnk)
+    end
+  end
+  
+  subject { Host.new }
+  
+  describe '#attach' do
+    it 'will set the link return self' do
+      expect(subject).to receive(:link=).with('new').and_return(subject)
+      subject.attach('new')
+    end
+  end
+  
+  describe '#affix' do
+    it 'will set the link and return the new link' do
+      expect(subject).to receive(:link=).with('new').and_return('new')
+      subject.affix('new')
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'vigilem/core/adapters/basic_adapter'
+
+describe Vigilem::Core::Adapters::BasicAdapter do
+  
+  class InitlessBasicHost
+    include Vigilem::Core::Adapters::BasicAdapter
+  end
+  
+  class BasicHost
+    include Vigilem::Core::Adapters::BasicAdapter
+    
+    def initialize(lnk=nil)
+      initialize_basic_adapter(lnk)
+    end
+  end
+  
+  subject { BasicHost.new }
+  
+  describe '#initialize_basic_adapter' do
+    it 'sets @link' do
+      expect(InitlessBasicHost.new.instance_variable_defined?(:@link)).to be_falsey
+    end
+  end
+  
+  class Observe
+    
+    attr_writer :notifications
+    
+    def update(type, value)
+      notifications << [type, value]
+    end
+    
+    def notifications
+      @notifications ||= []
+    end
+  end
+  
+  describe '#link=' do
+    it 'will set to changed when link is changed' do
+      subject.add_observer(obs = Observe.new)
+      subject.link = 'new'
+      expect(obs.notifications).to include(['link', 'new'])
+    end
+  end
+  
+  describe '#source' do
+    
+  end
+  
+  describe '#link' do
+    
+  end
+end