jsound 0.1.0-java

data/lib/jsound/midi/messages/note_off.rb

@@ -0,0 +1,10 @@
+module JSound
+  module Midi
+    module Messages
+
+      class NoteOff < NoteOn
+      end
+
+    end
+  end
+end

data/lib/jsound/midi/messages/note_on.rb

@@ -0,0 +1,29 @@
+module JSound
+  module Midi
+    module Messages
+
+      class NoteOn < Message
+
+        def initialize(pitch, velocity=127, channel=0, options={})
+          super([pitch,velocity], channel, options)
+        end
+
+        alias pitch data1
+        alias pitch= data1=
+
+        alias velocity data2
+        alias velocity= data2=
+
+        def self.from_java(java_message, options={})
+          new java_message.data1, java_message.data2, java_message.channel, options.merge({:java_message => java_message})
+        end
+
+        def clone
+          self.class.new(pitch,velocity,@channel)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/jsound/midi/messages/pitch_bend.rb

@@ -0,0 +1,43 @@
+module JSound
+  module Midi
+    module Messages
+
+      class PitchBend < Message
+
+        attr_reader :value
+
+        def initialize(value, channel=0, options={})
+          super(nil, channel, options)
+          self.value = value # we set #data as a side-effect here
+        end
+
+        # @param value [Fixnum] an 14-bit int in the range 0-16383 (8192 is no bend)
+        def value= value
+          @value = value
+          self.data = Convert.to_7bit(value)
+        end
+
+        def data= data
+          super
+          @value = Convert.from_7bit(*data)
+        end
+
+        # @param f [Float] in the range -1.0 to 1.0
+        def self.from_f(f, channel=0, options={})
+          new Convert.normalized_float_to_14bit(f), channel=0, options
+        end
+
+        def self.from_java(java_message, options={})
+          value = Convert.from_7bit(java_message.data1, java_message.data2)
+          new value, java_message.channel, options.merge({:java_message => java_message})
+        end
+
+        def clone
+          self.class.new(@value,@channel)
+        end
+
+      end
+
+    end
+  end      
+end

data/lib/jsound/midi/messages/poly_pressure.rb

@@ -0,0 +1,29 @@
+module JSound
+  module Midi
+    module Messages
+
+      class PolyPressure < Message
+
+        def initialize(pitch, pressure, channel=0, options={})
+          super([pitch,pressure], channel, options)
+        end
+
+        alias pitch data1
+        alias pitch= data1=
+
+        alias pressure data2
+        alias pressure= data2=
+
+        def self.from_java(java_message, options={})
+          new java_message.data1, java_message.data2, java_message.channel, options.merge({:java_message => java_message})
+        end
+
+        def clone
+          self.class.new(pitch,pressure,@channel)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/jsound/midi/messages/program_change.rb

@@ -0,0 +1,27 @@
+module JSound
+  module Midi
+    module Messages
+
+      class ProgramChange < Message
+
+        def initialize(program, channel=0, options={})
+          super([program,0], channel, options)
+          @program = program
+        end
+
+        alias program data1
+        alias program= data1=
+
+        def self.from_java(java_message, options={})
+          new java_message.data1, java_message.channel, options.merge({:java_message => java_message})
+        end
+
+        def clone
+          self.class.new(program,@channel)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/jsound/type_from_class_name.rb

@@ -0,0 +1,23 @@
+module JSound::Mixins
+
+  # Provides a default implementation of .type for the Class, based on the class name.
+  module TypeFromClassName
+
+    # Add ClassMethods to the including class.
+    def self.included(base) 
+      base.extend(ClassMethods) 
+    end 
+
+    # Class-level methods added when including TypeFromClassName
+    module ClassMethods
+
+      # Extract the class name (from fully qualified Module::Class string)
+      # and convert camel case to snake case. 
+      # @example JSound::Midi::Messages::NoteOn => :note_on
+      def type             
+        name.split('::').last.gsub(/(.)([A-Z])/,'\1_\2').downcase.to_sym
+      end
+    end
+
+  end
+end

data/spec/jsound/convert_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module JSound
+  describe Convert do
+
+    it 'should define MAX_14BIT_VALUE as the maximum value for 14-bit integers' do
+      Convert::MAX_14BIT_VALUE.should == (127 + (127 << 7))
+    end
+    
+    context 'with Convert included' do      
+      include Convert
+
+      describe '#to_7bit' do
+        it 'should convert positive integers to 7-bit [least_significant,most_significant]' do
+          to_7bit(    0).should == [  0,  0]
+          to_7bit(    1).should == [  1,  0]
+          to_7bit(  127).should == [127,  0]
+          to_7bit(  128).should == [  0,  1]
+          to_7bit(  129).should == [  1,  1]
+          to_7bit(16255).should == [127,126]
+          to_7bit(16256).should == [  0,127]
+          to_7bit(16257).should == [  1,127]
+          to_7bit(16383).should == [127,127]
+        end
+        it 'should be the inverse of #from_7bit' do
+          for lsb in 0..7
+            for msb in 0..7
+              to_7bit(from_7bit(lsb,msb)).should == [lsb,msb]
+            end
+          end
+        end
+      end
+
+      describe '#from_7bit' do
+        it 'should convert 7-bit [least_significant,most_significant] to an integer' do
+          from_7bit(  0,  0).should ==     0
+          from_7bit(  1,  0).should ==     1
+          from_7bit(127,  0).should ==   127
+          from_7bit(  0,  1).should ==   128
+          from_7bit(  1,  1).should ==   129
+          from_7bit(127,126).should == 16255
+          from_7bit(  0,127).should == 16256
+          from_7bit(  1,127).should == 16257
+          from_7bit(127,127).should == 16383
+        end
+        it 'should be the inverse of #to_7bit' do
+          for i in 0..16383
+            from_7bit(*to_7bit(i)).should == i
+          end
+        end
+      end
+
+      describe '#normalized_float_to_14bit' do
+        it 'should scale floats in the range [-1.0, 1.0] to [0, 16383]' do
+          normalized_float_to_14bit(-1.0).should ==     0
+          normalized_float_to_14bit(-0.5).should ==  4096
+          normalized_float_to_14bit( 0.0).should ==  8192
+          normalized_float_to_14bit( 0.5).should == 12287
+          normalized_float_to_14bit( 1.0).should == 16383
+        end
+        it 'should convert 1.0 to MAX_14BIT_VALUE' do
+          normalized_float_to_14bit(1.0).should == Convert::MAX_14BIT_VALUE
+        end
+      end
+    end
+
+  end
+end

data/spec/jsound/midi/device_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module JSound::Midi
+
+  describe Device do
+    let(:device)   { Device.new }
+    let(:output) { mock('device') }
+
+    describe '#open' do
+      it "does nothing" do
+        # just checking that device implements the method
+        device.open
+      end
+    end
+
+    describe '#open?' do
+      it "is true, because the abstract Device is always open" do
+        device.open?.should be_true
+      end
+    end
+
+    describe '#close' do
+      it "does nothing" do
+        # just checking that device implements the method
+        device.close
+      end
+    end
+
+    describe "#type" do
+      it "is :pass_through" do
+        device.type.should == :pass_through
+      end
+    end
+
+    describe '#output' do
+      it "is the output of this device's messages" do
+        device.output = output
+        device.output.should == output
+      end
+    end
+
+    describe '#>>' do
+      it 'should connect to a output' do
+        device >> output
+        device.output.should == output
+      end
+    end
+
+    describe '#message' do
+      it 'should send messages to the connected output' do
+        device >> output
+        output.should_receive(:message).with('the_message')
+        device.message 'the_message'
+      end
+    end
+
+    describe '#<=' do
+      it 'should behave like #send_message' do
+        device >> output
+        output.should_receive(:message).with('the_message')
+        device <= 'the_message'
+      end
+    end
+
+    it 'should pass through messages by default' do
+      pass_through = Device.new
+      device >> pass_through >> output 
+      device.output.should == pass_through
+      pass_through.output.should == output   
+      output.should_receive(:message).with('message')
+      device <= 'message'      
+    end
+
+  end
+end

data/spec/jsound/midi/devices/generator_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module JSound::Midi::Devices
+  describe Generator do
+
+    let(:generator) { Generator.new }
+    let(:output) { mock('device') }
+    before { generator >> output }
+
+    it "should generate note_on messages" do
+      output.should_receive(:message).once.with note_on_message(0)
+      generator.note_on(0)
+    end
+
+    it "should generate note_off messages" do
+      output.should_receive(:message).once.with note_off_message(0)
+      generator.note_off(0)
+    end
+
+  end
+end

data/spec/jsound/midi/devices/output_device_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module JSound::Midi::Devices
+  describe OutputDevice do
+
+    let(:device) { OutputDevice.new }
+    let(:another_device) { mock 'device' }
+
+    describe "#output=" do
+      it "should raise an error, since outputs cannot have outputs assigned" do
+        lambda{ device.output = another_device }.should raise_error
+      end
+    end
+
+    describe "#>>" do
+      it "should raise an error, since outputs cannot have outputs assigned" do
+        lambda{ device >> another_device }.should raise_error
+      end
+    end
+
+  end
+end

data/spec/jsound/midi/devices/recorder_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module JSound::Midi::Devices
+  describe Recorder do
+    let(:recorder) { Recorder.new }
+
+    context 'initial state' do
+      it 'should be recording by default' do
+        recorder <= :message
+        recorder.messages.should == [:message]
+      end
+
+      it 'should not record anything when the constructor argument is false' do
+        recorder = Recorder.new(false)
+        recorder <= :message
+        recorder.messages.should be_empty
+      end
+    end
+
+    describe '#start' do
+      it 'should start recording' do
+        recorder.start
+        recorder <= :message
+        recorder.messages.should == [:message]
+      end
+    end
+
+    describe '#messages' do
+      it 'should return all recorded messages in an Array' do
+        recorder.start
+        recorder <= :one
+        recorder <= 2
+        recorder <= 'three'
+        recorder.messages.should == [:one, 2, 'three']
+      end
+    end
+
+    describe '#messages_with_timestamps' do
+      it 'should return all recorded [message,timestamp] pairs in an Array' do
+        recorder.start
+        time = Time.now.to_i
+        recorder <= :one
+        recorder <= 2
+        recorder <= 'three'
+        # assuming this test all happens within a small fraction of a second:
+        recorder.messages_with_timestamps.should == [[:one,time], [2,time], ['three',time]]
+      end
+    end
+
+    describe '#stop' do
+      it 'should stop recording' do
+        recorder.start
+        recorder <= :message_while_started        
+        recorder.stop      
+        recorder <= :message_while_stopped
+        recorder.messages.should == [:message_while_started]      
+      end
+    end
+
+    describe '#clear' do
+      it 'should clear the recorded messages' do
+        recorder.start
+        recorder <= :message
+        recorder.clear
+        recorder.messages.should be_empty
+      end
+    end
+
+    describe '#recording?' do
+      it 'should be true in the initial state' do
+        recorder.recording?.should be_true
+      end
+      it 'should be false in the initial state when given a false constructor argument' do
+        Recorder.new(false).recording?.should be_false
+      end
+      it 'should be true after #start' do
+        recorder.start
+        recorder.recording?.should be_true
+      end
+      it 'should be false after #end' do
+        recorder.start
+        recorder.stop
+        recorder.recording?.should be_false
+      end
+    end
+
+  end
+end