mmplayer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b444046bc6129a272ad1354fd79e0226d3fed0f6
+  data.tar.gz: 7a58cbaec278585178e5ea420e3be977711a5f65
+SHA512:
+  metadata.gz: 7d73ce2e7db56b04f05bde2ce3a713a0b15cb6ed37f944d6d9de8d45859ad6e70265c3f818056aa6e5e8b70f536ae64f265301e39b2986829c0f7080b26ba2aa
+  data.tar.gz: 137bf592cad461210938a051ffad361b48019a55d87a788f76a48bdde80cd767c3729238fcb9c983c5094e44337bef934a13eeed852d1a57799e1ab483eb6689

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2015 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.md

@@ -0,0 +1,62 @@
+# mmplayer
+
+![image](http://i.imgur.com/Te9nymX.png)
+
+Control [MPlayer](http://en.wikipedia.org/wiki/MPlayer) with MIDI
+
+## Install
+
+You'll need to install MPlayer before using this.  That can usually be accomplished with a package manager eg `brew install mplayer` depending on what OS you're using.
+
+This project itself can be installed as a Ruby Gem using 
+
+`gem install mmplayer` 
+
+Or if you're using Bundler, add this to your Gemfile
+
+`gem "mmplayer"`
+
+## Usage
+
+MMplayer provides a Ruby DSL to define interactions between MIDI input and MPlayer
+
+```ruby
+require "mmplayer"
+
+@input = UniMIDI::Input.gets
+
+@player = MMPlayer.new(@input, :mplayer_flags => "-fs") do
+
+  rx_channel 0
+
+  system(:start) { play("1.mov") }
+  
+  note(1) { play("2.mov") }
+  note("C2") { play("3.mov") }
+
+  cc(1) { |value| volume(:set, value) }
+  cc(20) { |value| seek(to_percent(value), :percent) }
+
+end
+
+@player.start
+
+```
+
+An annotated breakdown of this example can be found [here](https://github.com/arirusso/mmplayer/blob/master/examples/simple.rb)
+
+[The MPlayer Man Page](http://www.mplayerhq.hu/DOCS/man/en/mplayer.1.html#GENERAL OPTIONS) has a full list of MPlayer startup flags
+
+All MPlayer runtime commands enabled by the [mplayer-ruby](https://rubygems.org/gems/mplayer-ruby) project are available here too. (eg `seek` and `volume` in the example above)
+
+[The RDOC for mplayer-ruby](http://mplayer-ruby.rubyforge.org/mplayer-ruby/index.html) has a full list of runtime commands
+
+##Author
+
+* [Ari Russo](http://github.com/arirusso) <ari.russo at gmail.com>
+
+##License
+
+Apache 2.0, See LICENSE file
+
+Copyright (c) 2015 [Ari Russo](http://arirusso.com)

data/lib/mmplayer.rb

@@ -0,0 +1,33 @@
+# MMPlayer
+# Control MPlayer with MIDI
+#
+# (c)2015 Ari Russo
+# Apache 2.0 License
+
+# libs
+require "forwardable"
+require "midi-eye"
+require "mplayer-ruby"
+require "scale"
+require "unimidi"
+
+# modules
+require "mmplayer/helper/numbers"
+require "mmplayer/instructions/midi"
+require "mmplayer/instructions/player"
+
+# classes
+require "mmplayer/context"
+require "mmplayer/midi"
+require "mmplayer/player"
+
+module MMPlayer
+
+  VERSION = "0.0.1"
+
+  # Shortcut to Context constructor
+  def self.new(*args, &block)
+    Context.new(*args, &block)
+  end
+
+end

data/lib/mmplayer/context.rb

@@ -0,0 +1,47 @@
+module MMPlayer
+
+  # DSL context for interfacing an instance of MPlayer with MIDI
+  class Context
+
+    include Helper::Numbers
+    include Instructions::MIDI
+    include Instructions::Player
+
+    attr_reader :midi, :player
+
+    # @param [UniMIDI::Input] midi_input
+    # @param [Hash] options
+    # @option options [String] :mplayer_flags The command-line flags to invoke MPlayer with
+    # @option options [Fixnum] :receive_channel (also: :rx_channel) A MIDI channel to subscribe to. By default, responds to all
+    # @yield
+    def initialize(midi_input, options = {}, &block)
+      @midi = MIDI.new(midi_input, :receive_channel => options[:receive_channel] || options[:rx_channel])
+      @player = Player.new(:flags => options[:mplayer_flags])
+      instance_eval(&block) if block_given?
+    end
+
+    # Start listening for MIDI
+    # Note that MPlayer will start when Context#play (aka Instructions::Player#play) is called
+    # @param [Hash] options
+    # @option options [Boolean] :background Whether to run in a background thread
+    # @return [Boolean]
+    def start(options = {})
+      @midi.start
+      unless !!options[:background]
+        loop { sleep(0.1) } until @player.active?
+        loop { sleep(0.1) } while @player.active?
+      end
+      true
+    end
+
+    # Stop the player
+    # @return [Boolean]
+    def stop
+      @midi.stop
+      @player.quit
+      true
+    end
+
+  end
+
+end

data/lib/mmplayer/helper/numbers.rb

@@ -0,0 +1,26 @@
+module MMPlayer
+
+  module Helper
+
+    # Number conversion
+    module Numbers
+
+      # Converts a percentage to a 7-bit int value eg 50 -> 0x40
+      # @param [Fixnum] num
+      # @return [Fixnum]
+      def to_midi_value(num)
+        Scale.transform(num).from(0..100).to(0..127.0).round
+      end
+
+      # Converts a MIDI 7-bit int value to a percentage eg 0x40 -> 50
+      # @param [Fixnum] num
+      # @return [Fixnum]
+      def to_percent(num)
+        Scale.transform(num).from(0..127).to(0..100.0).round
+      end
+
+    end
+
+  end
+
+end

data/lib/mmplayer/instructions/midi.rb

@@ -0,0 +1,46 @@
+module MMPlayer
+
+  module Instructions
+
+    # Instructions for dealing with MIDI
+    module MIDI
+
+      # Set the MIDI channel to receive messages on
+      # @param [Fixnum, nil] num The channel number 0-15 or nil for all
+      def receive_channel(num)
+        @midi.channel = num
+      end
+      alias_method :rx_channel, :receive_channel
+
+      # Assign a callback for a given MIDI system command
+      # @param [String, Symbol] note A MIDI system command eg :start, :continue, :stop
+      # @param [Proc] callback The callback to execute when a matching message is received
+      # @return [Hash]
+      def on_system(command, &callback)
+        @midi.add_system_callback(command, &callback)
+      end
+      alias_method :system, :on_system
+
+      # Assign a callback for a given MIDI note
+      # @param [Fixnum, String] note A MIDI note eg 64 "F4"
+      # @param [Proc] callback The callback to execute when a matching message is received
+      # @return [Hash]
+      def on_note(note, &callback)
+        @midi.add_note_callback(note, &callback)
+      end
+      alias_method :note, :on_note
+
+      # Assign a callback for the given MIDI control change
+      # @param [Fixnum] index The MIDI control change index to assign the callback for
+      # @param [Proc] callback The callback to execute when a matching message is received
+      # @return [Hash]
+      def on_cc(index, &callback)
+        @midi.add_cc_callback(index, &callback)
+      end
+      alias_method :cc, :on_cc
+
+    end
+
+  end
+
+end

data/lib/mmplayer/instructions/player.rb

@@ -0,0 +1,31 @@
+module MMPlayer
+
+  module Instructions
+
+    # Instructions dealing with the MPlayer
+    module Player
+
+      # Add delegators to local player methods
+      def self.included(base)
+        base.send(:extend, Forwardable)
+        base.send(:def_delegators, :@player, :active?, :play, :progress)
+      end
+
+      # Add all of the MPlayer::Slave methods to the context as instructions
+      def method_missing(method, *args, &block)
+        if @player.mplayer_respond_to?(method)
+          @player.mplayer_send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      # Add all of the MPlayer::Slave methods to the context as instructions
+      def respond_to_missing?(method, include_private = false)
+        super || @player.mplayer_respond_to?(method)
+      end
+
+    end
+
+  end
+end

data/lib/mmplayer/midi.rb

@@ -0,0 +1,105 @@
+module MMPlayer
+
+  # Wrapper for MIDI functionality
+  class MIDI
+
+    attr_reader :channel, :config, :listener
+
+    # @param [UniMIDI::Input] input
+    # @param [Hash] options
+    # @option options [Fixnum] :receive_channel A MIDI channel to subscribe to. By default, responds to all
+    def initialize(input, options = {})
+      @channel = options[:receive_channel]
+      @config = {
+        :cc => {},
+        :note => {},
+        :system => {}
+      }
+      @listener = MIDIEye::Listener.new(input)
+    end
+
+    # Add a callback for a given MIDI system message
+    # @param [String, Symbol] command The MIDI system command eg :start, :stop
+    # @param [Proc] callback The callback to execute when the given MIDI command is received
+    # @return [Hash]
+    def add_system_callback(command, &callback)
+      @config[:system][command] = callback
+      @config[:system]
+    end
+
+    # Add a callback for a given MIDI note
+    # @param [Fixnum, String] note The MIDI note to add a callback for eg 64 "E4"
+    # @param [Proc] callback The callback to execute when the given MIDI note is received
+    # @return [Hash]
+    def add_note_callback(note, &callback)
+      @config[:note][note] = callback
+      @config[:note]
+    end
+
+    # Add a callback for a given MIDI control change
+    # @param [Fixnum] index The MIDI control change index to add a callback for eg 10
+    # @param [Proc] callback The callback to execute when the given MIDI control change is received
+    # @return [Hash]
+    def add_cc_callback(index, &callback)
+      @config[:cc][index] = callback
+      @config[:cc]
+    end
+
+    # Stop the MIDI listener
+    # @return [Boolean]
+    def stop
+      @listener.stop
+    end
+
+    # Change the subscribed MIDI channel (or nil for all)
+    # @param [Fixnum, nil] channel
+    # @return [Fixnum, nil]
+    def channel=(channel)
+      @listener.event.clear
+      @channel = channel
+      populate_listener if @listener.running?
+      @channel
+    end
+
+    # Start the MIDI listener
+    # @return [Boolean]
+    def start
+      populate_listener
+      @listener.start(:background => true)
+      true
+    end
+
+    private
+
+    # Populate the MIDI listener events
+    def populate_listener
+      # Channel messages
+      listener_options = {}
+      # omni by default
+      listener_options[:channel] = @channel unless @channel.nil?
+      @listener.on_message(listener_options.merge(:class => MIDIMessage::NoteOn)) do |event|
+        message = event[:message]
+        unless (callback = @config[:note][message.note] || @config[:note][message.name]).nil?
+          callback.call(message.velocity)
+        end
+      end
+      @listener.on_message(listener_options.merge(:class => MIDIMessage::ControlChange)) do |event|
+        message = event[:message]
+        unless (callback = @config[:cc][message.index] || @config[:cc][message.name]).nil?
+          callback.call(message.value)
+        end
+      end
+      # Short messages
+      @listener.on_message(:class => MIDIMessage::SystemRealtime) do |event|
+        message = event[:message]
+        name = message.name.downcase.to_sym
+        unless (callback = @config[:system][name]).nil?
+          callback.call
+        end
+      end
+      true
+    end
+
+  end
+
+end

data/lib/mmplayer/player.rb

@@ -0,0 +1,142 @@
+module MMPlayer
+
+  # Wrapper for MPlayer functionality
+  class Player
+
+    # @param [Hash] options
+    # @option options [String] :flags MPlayer command-line flags to use on startup
+    def initialize(options = {})
+      @mplayer_messages = []
+      @flags = "-fixed-vo -idle"
+      @flags += " #{options[:flags]}" unless options[:flags].nil?
+    end
+
+    # Play a media file
+    # @param [String] file
+    # @return [Boolean]
+    def play(file)
+      ensure_player(file)
+      if @player.nil?
+        false
+      else
+        @player.load_file(file)
+        true
+      end
+    end
+
+    # Is MPlayer active?
+    # @return [Boolean]
+    def active?
+      !@player.nil? && !@player.stdout.gets.nil?
+    end
+
+    # Media progress information
+    # eg {
+    #  :length => 90.3,
+    #  :percent => 44,
+    #  :position => 40.1
+    # }
+    # Length and position are in seconds
+    # @return [Hash, nil]
+    def progress
+      unless (time = poll_mplayer_progress).nil?
+        time[:percent] = get_percentage(time)
+        time
+      end
+    end
+
+    # Shortcut to send a message to the MPlayer
+    # @return [Object]
+    def mplayer_send(method, *args, &block)
+      if @player.nil? && MPlayer::Slave.method_defined?(method)
+        # warn
+      else
+        send_mplayer_message { @player.send(method, *args, &block) }
+      end
+    end
+
+    # Does the MPlayer respond to the given message?
+    # @return [Boolean]
+    def mplayer_respond_to?(method, include_private = false)
+      (@player.nil? && MPlayer::Slave.method_defined?(method)) ||
+        @player.respond_to?(method)
+    end
+
+    # Cause MPlayer to exit
+    # @return [Boolean]
+    def quit
+      @player.quit
+      @player_thread.kill
+      true
+    end
+
+    private
+
+    # Sweep for leftover/hanging message threads
+    def sweep_messages
+      if @mplayer_messages.empty?
+        false
+      else
+        sleep(0.01)
+        @mplayer_messages.each(&:kill)
+        true
+      end
+    end
+
+    # Send mplayer a message async
+    def send_mplayer_message(&block)
+      sweep_messages
+      thread = Thread.new do
+        begin
+          yield
+        rescue Exception => exception
+          Thread.main.raise(exception)
+        end
+      end
+      thread.abort_on_exception = true
+      @mplayer_messages << thread
+      thread
+    end
+
+    # Get progress percentage from the MPlayer report
+    def get_percentage(report)
+      percent = (report[:position] / report[:length]) * 100
+      percent.round
+    end
+
+    # Poll MPlayer for progress information
+    def poll_mplayer_progress
+      time = nil
+      send_mplayer_message do
+        time = {
+          :length => get_mplayer_float("time_length"),
+          :position => get_mplayer_float("time_pos")
+        }
+      end
+      time
+    end
+
+    # Poll a single MPlayer value for the given key
+    def get_mplayer_float(key)
+      @player.get(key).strip.to_f
+    end
+
+    # Ensure that the MPlayer process is invoked
+    # @param [String] file The media file to invoke MPlayer with
+    # @return [MPlayer::Slave]
+    def ensure_player(file)
+      if @player.nil?
+        @player_thread = Thread.new do
+          begin
+            @player = MPlayer::Slave.new(file, :options => @flags)
+          rescue Exception => exception
+            Thread.main.raise(exception)
+          end
+        end
+        @player_thread.abort_on_exception = true
+      end
+    end
+
+  end
+
+end

data/test/context_test.rb

@@ -0,0 +1,64 @@
+require "helper"
+
+class MMPlayer::ContextTest < Minitest::Test
+
+  context "Context" do
+
+    setup do
+      @input = Object.new
+      @context = MMPlayer::Context.new(@input)
+      @player = Object.new
+      @context.player.stubs(:ensure_player).returns(@player)
+      @context.player.stubs(:quit).returns(true)
+      @context.player.stubs(:active?).returns(true)
+    end
+
+    teardown do
+      @context.player.unstub(:ensure_player)
+      @context.player.unstub(:quit)
+      @context.player.unstub(:active?)
+    end
+
+    context "#start" do
+
+      setup do
+        @context.midi.listener.expects(:on_message).times(3)
+        @context.midi.listener.expects(:start).once
+      end
+
+      teardown do
+        @context.midi.listener.unstub(:on_message)
+        @context.midi.listener.unstub(:start)
+      end
+
+      should "activate player" do
+        assert @context.start(:background => true)
+        @context.stop
+      end
+
+    end
+
+    context "#stop" do
+
+      setup do
+        @context.midi.listener.expects(:on_message).times(3)
+        @context.midi.listener.expects(:start).once
+        @context.midi.listener.expects(:stop).once
+        @context.player.expects(:quit).once
+        assert @context.start(:background => true)
+      end
+
+      teardown do
+        @context.midi.listener.unstub(:on_message)
+        @context.midi.listener.unstub(:start)
+        @context.player.unstub(:quit)
+      end
+
+      should "stop player" do
+        @context.stop
+      end
+
+    end
+
+  end
+end

data/test/helper.rb

@@ -0,0 +1,6 @@
+$:.unshift(File.join("..", "lib"))
+
+require "minitest/autorun"
+require "mocha/test_unit"
+require "shoulda-context"
+require "mmplayer"

data/test/helper/numbers_test.rb

@@ -0,0 +1,57 @@
+require "helper"
+
+class MMPlayer::Helper::NumbersTest < Minitest::Test
+
+  context "Numbers" do
+
+    setup do
+      @util = Object.new
+      @util.class.send(:include, MMPlayer::Helper::Numbers)
+    end
+
+    context "#to_midi_value" do
+
+      should "convert 0" do
+        val = @util.to_midi_value(0)
+        refute_nil val
+        assert_equal 0x0, val
+      end
+
+      should "convert 64" do
+        val = @util.to_midi_value(50)
+        refute_nil val
+        assert_equal 0x40, val
+      end
+
+      should "convert 127" do
+        val = @util.to_midi_value(100)
+        refute_nil val
+        assert_equal 0x7F, val
+      end
+
+    end
+
+    context "#to_percent" do
+
+      should "convert 0%" do
+        val = @util.to_percent(0x0)
+        refute_nil val
+        assert_equal 0, val
+      end
+
+      should "convert 50%" do
+        val = @util.to_percent(0x40)
+        refute_nil val
+        assert_equal 50, val
+      end
+
+      should "convert 100%" do
+        val = @util.to_percent(0x7F)
+        refute_nil val
+        assert_equal 100, val
+      end
+
+    end
+
+  end
+end

data/test/instructions/midi_test.rb

@@ -0,0 +1,78 @@
+require "helper"
+
+class MMPlayer::Instructions::MIDITest < Minitest::Test
+
+  context "MIDI" do
+
+    setup do
+      @input = Object.new
+      @context = MMPlayer::Context.new(@input)
+      assert @context.kind_of?(MMPlayer::Instructions::MIDI)
+    end
+
+    context "#note" do
+
+      setup do
+        @context.midi.expects(:add_note_callback).once.returns({})
+      end
+
+      teardown do
+        @context.midi.unstub(:add_note_callback)
+      end
+
+      should "assign callback" do
+        refute_nil @context.note(1) { something }
+      end
+
+    end
+
+    context "#cc" do
+
+      setup do
+        @context.midi.expects(:add_cc_callback).once.returns({})
+      end
+
+      teardown do
+        @context.midi.unstub(:add_cc_callback)
+      end
+
+      should "assign callback" do
+        refute_nil @context.cc(1) { |val| something }
+      end
+
+    end
+
+    context "#system" do
+
+      setup do
+        @context.midi.expects(:add_system_callback).once.returns({})
+      end
+
+      teardown do
+        @context.midi.unstub(:add_system_callback)
+      end
+
+      should "assign callback" do
+        refute_nil @context.system(:stop) { something }
+      end
+
+    end
+
+    context "#receive_channel" do
+
+      setup do
+        @context.midi.expects(:channel=).once.with(3).returns(3)
+      end
+
+      teardown do
+        @context.midi.unstub(:channel=)
+      end
+
+      should "assign callback" do
+        refute_nil @context.receive_channel(3)
+      end
+
+    end
+
+  end
+end

data/test/instructions/player_test.rb

@@ -0,0 +1,46 @@
+require "helper"
+
+class MMPlayer::Instructions::PlayerTest < Minitest::Test
+
+  context "Player" do
+
+    setup do
+      @input = Object.new
+      @context = MMPlayer::Context.new(@input)
+      assert @context.kind_of?(MMPlayer::Instructions::Player)
+    end
+
+    context "#method_missing" do
+
+      setup do
+        @context.player.expects(:mplayer_send).once.with(:seek, 50, :percent).returns(true)
+      end
+
+      teardown do
+        @context.player.unstub(:mplayer_send)
+      end
+
+      should "delegate" do
+        refute_nil @context.seek(50, :percent)
+      end
+
+    end
+
+    context "#respond_to?" do
+
+      setup do
+        @context.player.expects(:mplayer_respond_to?).once.with(:seek).returns(true)
+      end
+
+      teardown do
+        @context.player.unstub(:mplayer_respond_to?)
+      end
+
+      should "delegate" do
+        refute_nil @context.respond_to?(:seek)
+      end
+
+    end
+
+  end
+end

data/test/midi_test.rb

@@ -0,0 +1,130 @@
+require "helper"
+
+class MMPlayer::MIDITest < Minitest::Test
+
+  context "MIDI" do
+
+    setup do
+      @input = Object.new
+      @midi = MMPlayer::MIDI.new(@input)
+    end
+
+    context "#start" do
+
+      setup do
+        @midi.listener.expects(:on_message).times(3)
+        @midi.listener.expects(:start).once
+      end
+
+      teardown do
+        @midi.listener.unstub(:on_message)
+        @midi.listener.unstub(:start)
+      end
+
+      should "activate callbacks" do
+        assert @midi.start
+      end
+
+    end
+
+    context "#add_note_callback" do
+
+      setup do
+        @var = nil
+        @midi.add_note_callback(10) { |vel| @var = vel }
+      end
+
+      should "store callback" do
+        refute_nil @midi.config[:note][10]
+        assert_equal Proc, @midi.config[:note][10].class
+      end
+
+    end
+
+    context "#add_system_callback" do
+
+      setup do
+        @var = nil
+        @midi.add_system_callback(:start) { |val| @var = val }
+      end
+
+      should "store callback" do
+        refute_nil @midi.config[:system][:start]
+        assert_equal Proc, @midi.config[:system][:start].class
+      end
+
+    end
+
+    context "#add_cc_callback" do
+
+      setup do
+        @var = nil
+        @midi.add_cc_callback(2) { |val| @var = val }
+      end
+
+      should "store callback" do
+        refute_nil @midi.config[:cc][2]
+        assert_equal Proc, @midi.config[:cc][2].class
+      end
+
+    end
+
+    context "#channel=" do
+
+      setup do
+        # stub out MIDIEye
+        @listener = Object.new
+        @listener.stubs(:event).returns([])
+        @midi.instance_variable_set("@listener", @listener)
+      end
+
+      teardown do
+        @listener.unstub(:clear)
+        @listener.unstub(:on_message)
+        @listener.unstub(:event)
+        @listener.unstub(:running?)
+      end
+
+      context "before listener is started" do
+
+        setup do
+          @listener.stubs(:running?).returns(false)
+          @listener.expects(:clear).never
+          @listener.expects(:on_message).never
+        end
+
+        should "change channel" do
+          assert_equal 3, @midi.channel = 3
+          assert_equal 3, @midi.channel
+        end
+
+        should "set channel nil" do
+          assert_equal nil, @midi.channel = nil
+          assert_nil @midi.channel
+        end
+      end
+
+      context "after listener is started" do
+
+        setup do
+          @listener.stubs(:running?).returns(true)
+          @listener.expects(:clear).once
+          @listener.expects(:on_message).times(3)
+        end
+
+        should "change channel" do
+          assert_equal 3, @midi.channel = 3
+          assert_equal 3, @midi.channel
+        end
+
+        should "set channel nil" do
+          assert_equal nil, @midi.channel = nil
+          assert_nil @midi.channel
+        end
+
+      end
+
+    end
+
+  end
+end

data/test/player_test.rb

@@ -0,0 +1,125 @@
+require "helper"
+
+class MMPlayer::PlayerTest < Minitest::Test
+
+  context "Player" do
+
+    setup do
+      # Stub out MPlayer completely
+      class MPlayer
+        def get(*args)
+          "0.1\n"
+        end
+      end
+      @player = MMPlayer::Player.new
+      @mplayer = MPlayer.new
+      @player.stubs(:ensure_player).returns(@mplayer)
+      @player.instance_variable_set("@player", @mplayer)
+      @player.instance_variable_set("@player_thread", Thread.new {})
+      @player.send(:ensure_player, "")
+    end
+
+    context "#mplayer_send" do
+
+      setup do
+        @mplayer.expects(:hello).once.returns(true)
+        @mplayer.expects(:send).once.with(:hello).returns(true)
+      end
+
+      teardown do
+        @mplayer.unstub(:send)
+      end
+
+      should "send messages to mplayer" do
+        assert @player.mplayer_send(:hello)
+      end
+
+    end
+
+    context "#mplayer_respond_to?" do
+
+      setup do
+        @player.send(:ensure_player, "")
+        @mplayer.expects(:respond_to?).with(:hello).once.returns(true)
+      end
+
+      teardown do
+        @mplayer.unstub(:respond_to?)
+      end
+
+      should "send messages to mplayer" do
+        assert @player.mplayer_respond_to?(:hello)
+      end
+
+    end
+
+    context "#get_percentage" do
+
+      should "calcuate percentage" do
+        val = @player.send(:get_percentage, { :length => 10.1, :position => 5.5 })
+        refute_nil val
+        assert_equal Fixnum, val.class
+        assert_equal 54, val
+      end
+
+    end
+
+    context "#quit" do
+
+      setup do
+        @mplayer.expects(:quit).once
+        @player.instance_variable_get("@player_thread").expects(:kill).once
+      end
+
+      teardown do
+        @mplayer.unstub(:quit)
+        @player.instance_variable_get("@player_thread").unstub(:kill)
+      end
+
+      should "exit MPlayer and kill the player thread" do
+        assert @player.quit
+      end
+
+    end
+
+    context "#progress" do
+      # TODO
+    end
+
+    context "#poll_mplayer_progress" do
+      # TODO
+    end
+
+    context "#get_mplayer_float" do
+
+      should "convert string to float" do
+        val = @player.send(:get_mplayer_float, "key")
+        refute_nil val
+        assert_equal Float, val.class
+        assert_equal 0.1, val
+      end
+
+    end
+
+    context "#play" do
+
+      setup do
+        @player.expects(:ensure_player).once.returns(@mplayer)
+        @mplayer.expects(:load_file).once
+      end
+
+      teardown do
+        @player.unstub(:ensure_player)
+        @mplayer.unstub(:load_file)
+      end
+
+      should "lazily invoke mplayer and play" do
+        assert @player.play("file.mov")
+        refute_nil @player.instance_variable_get("@player")
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,240 @@
+--- !ruby/object:Gem::Specification
+name: mmplayer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ari Russo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.5.0
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: analog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: midi-eye
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.9
+- !ruby/object:Gem::Dependency
+  name: midi-message
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+- !ruby/object:Gem::Dependency
+  name: mplayer-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: unimidi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+description: Define interactions between MIDI input and MPlayer
+email:
+- ari.russo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/mmplayer.rb
+- lib/mmplayer/context.rb
+- lib/mmplayer/helper/numbers.rb
+- lib/mmplayer/instructions/midi.rb
+- lib/mmplayer/instructions/player.rb
+- lib/mmplayer/midi.rb
+- lib/mmplayer/player.rb
+- test/context_test.rb
+- test/helper.rb
+- test/helper/numbers_test.rb
+- test/instructions/midi_test.rb
+- test/instructions/player_test.rb
+- test/midi_test.rb
+- test/player_test.rb
+homepage: http://github.com/arirusso/mmplayer
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: mmplayer
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Control MPlayer with MIDI
+test_files: []