unimidi 0.1.14

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2010-2011 Ari Russo
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.rdoc

@@ -0,0 +1,63 @@
+= UniMIDI
+
+== Summary
+
+Platform independent realtime MIDI input and output for Ruby.
+
+== Features
+
+* Supports Linux, JRuby, OSX, Windows and Cygwin
+* Both input and output to and from multiple devices concurrently
+* Agnostically handle different MIDI and SysEx Message types
+
+== Requirements
+
+Ruby 1.9.2 or JRuby 1.6.1 are strongly recommended
+
+One of the following libraries is required based on what platform is being used.  It should install automatically when you install the unimidi gem
+
+Platform
+
+* JRuby: {midi-jruby}[http://github.com/arirusso/midi-jruby]
+* Linux: {alsa-rawmidi}[http://github.com/arirusso/alsa-rawmidi]
+* OSX: {ffi-coremidi}[http://github.com/arirusso/ffi-coremidi]
+* Windows/Cygwin: {midi-winmm}[http://github.com/arirusso/midi-winmm]
+	
+== Install
+
+  gem install unimidi
+  
+No compilation required
+	
+== Examples
+
+* {input}[http://github.com/arirusso/unimidi/blob/master/examples/input.rb]
+* {output}[http://github.com/arirusso/unimidi/blob/master/examples/output.rb]
+
+{more}[http://github.com/arirusso/unimidi/blob/master/examples]
+
+== Tests
+
+* please see {test/config.rb}[http://github.com/arirusso/unimidi/blob/master/test/config.rb] before running tests
+
+== Documentation
+
+* {rdoc}[http://rdoc.info/gems/unimidi]
+
+== If you are using JRuby
+
+A couple of notes
+
+* You must be in 1.9 mode.  This is normally accomplished by passing --1.9 to JRuby at the command line.  For testing in 1.9 mode, use 
+    jruby --1.9 -S rake test
+* javax.sound has some documented issues with SysEx messages in some versions OSX Snow Leopard which do affect this library.
+	
+== Author 
+
+{Ari Russo}[http://github.com/arirusso] <ari.russo at gmail.com>
+		
+== License
+
+Apache 2.0, See the file LICENSE
+
+Copyright (c) 2010-2011 Ari Russo  

data/bin/unimidi

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'unimidi'
+
+opts = ARGV.length > 1 ? ARGV.slice(1, ARGV.length-1) : {} 
+  
+raise "No command specified" if ARGV.first.nil? 
+ 
+UniMIDI.command(ARGV.first.to_sym, opts)

data/lib/unimidi/adapter/alsa-rawmidi.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+#
+
+require 'alsa-rawmidi'
+
+module UniMIDI
+
+  module AlsaRawMIDIAdapter
+    
+    class Input < CongruousApiInput
+      defer_to AlsaRawMIDI::Input
+    end
+
+    class Output < CongruousApiOutput
+      defer_to AlsaRawMIDI::Output
+    end
+    
+    class Device < CongruousApiDevice
+      defer_to AlsaRawMIDI::Device
+      input_class Input
+      output_class Output
+    end
+    
+  end
+
+end

data/lib/unimidi/adapter/ffi-coremidi.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+#
+
+require 'coremidi'
+
+module UniMIDI
+
+  module CoreMIDIAdapter
+    
+    class Input < CongruousApiInput
+      defer_to CoreMIDI::Input
+    end
+
+    class Output < CongruousApiOutput
+      defer_to CoreMIDI::Output
+    end
+    
+    class Device < CongruousApiDevice
+      defer_to CoreMIDI::Entity
+      input_class Input
+      output_class Output
+    end
+    
+  end
+
+end

data/lib/unimidi/adapter/midi-jruby.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+#
+
+require 'midi-jruby'
+
+module UniMIDI
+
+  module MIDIJRubyAdapter
+    
+    class Input < CongruousApiInput
+      defer_to MIDIJRuby::Input
+    end
+
+    class Output < CongruousApiOutput
+      defer_to MIDIJRuby::Output
+    end
+    
+    class Device < CongruousApiDevice
+      defer_to MIDIJRuby::Device
+      input_class Input
+      output_class Output
+    end
+
+  end
+
+end

data/lib/unimidi/adapter/midi-winmm.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+#
+
+require 'midi-winmm'
+
+module UniMIDI
+
+  module MIDIWinMMAdapter
+    
+    class Input < CongruousApiInput
+      defer_to MIDIWinMM::Input
+    end
+
+    class Output < CongruousApiOutput
+      defer_to MIDIWinMM::Output
+    end
+    
+    class Device < CongruousApiDevice
+      defer_to MIDIWinMM::Device
+      input_class Input
+      output_class Output
+    end
+
+  end
+
+end

data/lib/unimidi/congruous_api_adapter.rb

@@ -0,0 +1,215 @@
+#!/usr/bin/env ruby
+#
+
+module UniMIDI
+
+  module CongruousApiAdapter
+
+    module Device
+      
+      def initialize(device_obj)        
+        @device = device_obj
+        @id = @device.id
+        @name = @device.name
+        @type = @device.type
+      end
+
+      # enable the device for use, can be passed a block to which the device will be passed back
+      def open(*a, &block)
+        @device.open(*a)
+        unless block.nil?
+          begin
+            yield(self)
+          ensure
+            close
+          end
+        else
+        self
+        end
+      end
+
+      # close the device
+      def close(*a)
+        @device.close(*a)
+      end
+
+      def self.included(base)
+        base.send(:attr_reader, :name)
+        base.send(:attr_reader, :id)
+        base.send(:attr_reader, :type)
+      end
+
+      module ClassMethods
+        
+        # returns the first device for this class
+        def first(*a)
+          dev = @deference[self].first(*a)
+          raise 'Device not found' if dev.nil?
+          new(dev)
+        end
+
+        # returns the last device for this class
+        def last(*a)
+          dev = @deference[self].last(*a)
+          raise 'Device not found' if dev.nil?
+          new(dev)          
+        end
+
+        # returns all devices in an array
+        def all
+          all_by_type.values.flatten
+        end
+
+        # returns all devices as a hash as such
+        #   { :input => [input devices], :output => [output devices] }
+        def all_by_type
+          {
+            :input => @deference[self].all_by_type[:input].map { |d| @input_class.new(d) },
+            :output => @deference[self].all_by_type[:output].map { |d| @output_class.new(d) }
+          }
+        end
+
+        def defer_to(klass)
+          @deference ||= {}
+          @deference[self] = klass
+        end
+
+        def input_class(klass)
+          @input_class = klass
+        end
+
+        def output_class(klass)
+          @output_class = klass
+        end
+
+      end
+
+    end
+
+  end
+
+  class CongruousApiInput
+    
+    include CongruousApiAdapter::Device
+    extend CongruousApiAdapter::Device::ClassMethods
+    extend Forwardable
+    
+    def_delegators :@device, :buffer
+    
+    #
+    # returns an array of MIDI event hashes as such:
+    #   [
+    #     { :data => [144, 60, 100], :timestamp => 1024 },
+    #     { :data => [128, 60, 100], :timestamp => 1100 },
+    #     { :data => [144, 40, 120], :timestamp => 1200 }
+    #   ]
+    #
+    # the data is an array of Numeric bytes
+    # the timestamp is the number of millis since this input was enabled
+    #
+    def gets(*a)
+      @device.gets(*a)
+    end
+
+    #
+    # same as gets but returns message data as string of hex digits as such:
+    #   [
+    #     { :data => "904060", :timestamp => 904 },
+    #     { :data => "804060", :timestamp => 1150 },
+    #     { :data => "90447F", :timestamp => 1300 }
+    #   ]
+    #
+    def gets_s(*a)
+      @device.gets_s(*a)
+    end
+    alias_method :gets_bytestr, :gets_s
+    alias_method :gets_hex, :gets_s
+
+    #
+    # returns an array of data bytes such as
+    #   [144, 60, 100, 128, 60, 100, 144, 40, 120]
+    #
+    def gets_data(*a)
+      arr = gets
+      arr.map { |msg| msg[:data] }.inject { |a,b| a + b }
+    end
+
+    #
+    # returns a string of data such as
+    #   "90406080406090447F"
+    #
+    def gets_data_s(*a)
+      arr = gets_bytestr
+      arr.map { |msg| msg[:data] }.join
+    end
+    alias_method :gets_data_bytestr, :gets_data_s
+    alias_method :gets_data_hex, :gets_data_s
+    
+    # clears the buffer
+    def clear_buffer
+      @device.buffer.clear
+    end
+    
+    # gets any messages in the buffer in the same format as CongruousApiInput#gets 
+    def gets_buffer(*a)
+      @device.buffer
+    end
+    
+    # gets any messages in the buffer in the same format as CongruousApiInput#gets_s
+    def gets_buffer_s(*a)
+      @device.buffer.map { |msg| msg[:data] = TypeConversion.numeric_byte_array_to_hex_string(msg[:data]); msg }
+    end
+    
+    # gets any messages in the buffer in the same format as CongruousApiInput#gets_data
+    def gets_buffer_data(*a)
+      @device.buffer.map { |msg| msg[:data] }
+    end
+
+    # returns all inputs
+    def self.all
+      @deference[self].all.map { |d| new(d) }
+    end
+
+  end
+
+  class CongruousApiOutput
+    
+    include CongruousApiAdapter::Device
+    extend CongruousApiAdapter::Device::ClassMethods
+    
+    # sends a message to the output. the message can be:
+    #
+    # bytes eg output.puts(0x90, 0x40, 0x40)
+    # an array of bytes eg output.puts([0x90, 0x40, 0x40])
+    # or a string eg output.puts("904040")
+    #
+    def puts(*a)
+      @device.puts(*a)
+    end
+
+    # sends a message to the output in a form of a string eg "904040".  this method does not do
+    # type checking and therefore is more performant than puts
+    def puts_s(*a)
+      @device.puts_s(*a)
+    end
+    alias_method :puts_bytestr, :puts_s
+    alias_method :puts_hex, :puts_s
+
+    # sends a message to the output in a form of bytes eg output.puts_bytes(0x90, 0x40, 0x40).
+    # this method does not do type checking and therefore is more performant than puts
+    def puts_bytes(*a)
+      @device.puts_bytes(*a)
+    end
+
+    # returns all outputs
+    def self.all
+      @deference[self].all.map { |d| new(d) }
+    end
+
+  end
+
+  class CongruousApiDevice
+    extend CongruousApiAdapter::Device::ClassMethods
+  end
+
+end

data/lib/unimidi/platform.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+#
+
+require 'singleton'
+
+module UniMIDI
+  
+  class Platform
+
+    include Singleton
+
+    attr_reader :interface
+    
+    def initialize
+      lib = case RUBY_PLATFORM
+        when /darwin/ then "ffi-coremidi"
+        when /java/ then "midi-jruby"
+        when /linux/ then "alsa-rawmidi"
+        when /mingw/ then "midi-winmm"
+        #when /win/ then "midi-winmm"
+      end
+      require("unimidi/adapter/#{lib}")
+      @interface = case RUBY_PLATFORM
+        when /darwin/ then CoreMIDIAdapter
+        when /java/ then MIDIJRubyAdapter
+        when /linux/ then AlsaRawMIDIAdapter
+        when /mingw/ then MIDIWinMMAdapter
+        #when /win/ then MIDIWinMMAdapter
+      end
+    end
+
+  end
+
+end
+

data/lib/unimidi/type_conversion.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+#
+
+module UniMIDI
+  
+  module TypeConversion
+      
+    # byte array to string of hex bytes 
+    def numeric_byte_array_to_hex_string(bytes)
+      bytes.map { |b| b.hex }.join
+    end
+      
+  end
+  
+end

data/lib/unimidi.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+#
+# A realtime MIDI interface for Ruby
+# (c)2010-2011 Ari Russo and licensed under the Apache 2.0 License
+#
+
+module UniMIDI
+  
+  VERSION = "0.1.14"
+ 
+end
+
+require 'forwardable'
+
+require 'unimidi/congruous_api_adapter'
+require 'unimidi/platform'
+require 'unimidi/type_conversion'
+
+module UniMIDI
+  extend(Platform.instance.interface)
+  include(Platform.instance.interface)
+  
+  def self.command(command, options = {})
+    if [:l, :list, :list_devices].include?(command)
+      require 'pp'
+      pp Device::all
+    else
+      raise "Command #{command.to_s} not found"
+    end      
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: unimidi
+version: !ruby/object:Gem::Version
+  version: 0.1.14
+  prerelease: 
+platform: ruby
+authors:
+- Ari Russo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-05-23 00:00:00.000000000 -04:00
+default_executable: unimidi
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: alsa-rawmidi
+  requirement: &9446868 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *9446868
+- !ruby/object:Gem::Dependency
+  name: ffi-coremidi
+  requirement: &9446532 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *9446532
+- !ruby/object:Gem::Dependency
+  name: midi-jruby
+  requirement: &9446244 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *9446244
+- !ruby/object:Gem::Dependency
+  name: midi-winmm
+  requirement: &9445956 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *9445956
+description: Platform Independent, realtime MIDI input and output for Ruby.
+email:
+- ari.russo@gmail.com
+executables:
+- unimidi
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/unimidi
+- lib/unimidi/adapter/alsa-rawmidi.rb
+- lib/unimidi/adapter/ffi-coremidi.rb
+- lib/unimidi/adapter/midi-jruby.rb
+- lib/unimidi/adapter/midi-winmm.rb
+- lib/unimidi/congruous_api_adapter.rb
+- lib/unimidi/platform.rb
+- lib/unimidi/type_conversion.rb
+- lib/unimidi.rb
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/arirusso/unimidi
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: unimidi
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Realtime MIDI input and output for Ruby.
+test_files: []