mtk 0.0.2 → 0.0.3

data/lib/mtk/pattern/sequence.rb

@@ -1,30 +0,0 @@
-module MTK
-  module Pattern
-
-    # A finite list of elements, which can be enumerated one at a time.
-    class Sequence < AbstractPattern
-
-      # Reset the sequence to the beginning
-      def rewind
-        @index = -1
-        super
-      end
-
-      ###################
-      protected
-
-      # (see AbstractPattern#advance!)
-      def advance!
-        super
-        @index += 1
-        raise StopIteration if @index >= @elements.length
-      end
-
-      # (see AbstractPattern#current)
-      def current
-        @elements[@index]
-      end
-    end
-
-  end
-end

data/lib/mtk/pitch_set.rb

@@ -1,84 +0,0 @@
-module MTK
-
-  # A set of {Pitch}es
-  #
-  class PitchSet
-
-    include Helper::Collection
-    include Transform::Mappable
-    include Transform::Transposable
-    include Transform::Invertible
-
-    attr_reader :pitches
-
-    def initialize(pitches)
-      @pitches = pitches.to_a.uniq.sort.freeze
-    end
-
-    def elements
-      @pitches
-    end
-
-    def self.from_a enumerable
-      new enumerable
-    end
-
-    def to_pitch_class_set
-      PitchClassSet.new @pitches.map{|p| p.pitch_class }
-    end
-
-    def pitch_classes
-      @pitch_classes ||= @pitches.map{|p| p.pitch_class }.uniq
-    end
-
-    # generate a chord inversion (positive numbers move the lowest notes up an octave, negative moves the highest notes down)
-    def inversion(number)
-      number = number.to_i
-      pitch_set = Array.new(@pitches)
-      if number > 0
-        number.times do |count|
-          index = count % pitch_set.length
-          pitch_set[index] += 12
-        end
-      else
-        number.abs.times do |count|
-          index = -(count + 1) % pitch_set.length # count from -1 downward to go backwards through the list starting at the end
-          pitch_set[index] -= 12
-        end
-      end
-      self.class.new pitch_set
-    end
-
-    def nearest(pitch_class)
-      self.transpose @pitches.first.pitch_class.distance_to(pitch_class)
-    end
-
-    # @param other [#pitches, #to_a, Array]
-    def == other
-      if other.respond_to? :pitches
-        @pitches == other.pitches
-      elsif other.respond_to? :to_a
-        @pitches == other.to_a
-      else
-        @pitches == other
-      end
-    end
-
-    def to_s
-      @pitches.inspect
-    end
-
-  end
-
-  # Construct a {PitchSet} from any supported type
-  def PitchSet(*anything)
-    anything = anything.first if anything.size == 1
-    case anything
-      when Array then PitchSet.new(anything.map{|elem| Pitch(elem) })
-      when PitchSet then anything
-      else PitchSet.new([Pitch(anything)])
-    end
-  end
-  module_function :PitchSet
-
-end

data/lib/mtk/sequencer/rhythmic_sequencer.rb

@@ -1,29 +0,0 @@
-module MTK
-  module Sequencer
-
-    # A Sequencer which uses a :rhythm type {Pattern} to determine the delta times between entries in the {Timeline}.
-    class RhythmicSequencer < AbstractSequencer
-
-      def initialize(patterns, options={})
-        patterns = patterns.clone
-        patterns.each_with_index do |pattern, index|
-          if pattern.type == :rhythm
-            @rhythm = pattern
-            patterns.delete_at index # so we don't enumerate the rhythm values in EventBuilder
-          end
-        end
-        super(patterns, options)
-      end
-
-     ########################
-      protected
-
-      # (see AbstractSequencer#advance!)
-      def advance!
-        @time += @rhythm.next
-      end
-
-    end
-
-  end
-end

data/lib/mtk/transform/invertible.rb

@@ -1,15 +0,0 @@
-module MTK::Transform
-
-  # {Mappable} class whose elements can handle the :invert message
-  # @note Classes including this module should include either MTK::Collection or provide a #first method
-  module Invertible
-
-    # Invert all elements around the given inversion point
-    # @param inversion_point [Numeric] the value around which all elements will be inverted (defaults to the first element in the collection)
-    def invert(inversion_point=first)
-      map{|elem| elem.invert(inversion_point) }
-    end
-
-  end
-
-end

data/lib/mtk/transform/mappable.rb

@@ -1,18 +0,0 @@
-module MTK::Transform
-
-  # Similar to Enumerable, but relies on the including Class's from_a method to
-  # provide an implementation of #map which returns an object of the same type.
-  module Mappable
-    include Enumerable
-
-    # the original Enumerable#map implementation, which returns an Array
-    alias enumerable_map map
-
-    # the overriden #map implementation, which returns an object of the same type
-    def map &block
-      self.class.from_a(enumerable_map &block)
-    end
-
-  end
-
-end

data/lib/mtk/transform/set_theory_operations.rb

@@ -1,34 +0,0 @@
-module MTK::Transform
-
-  # {Helper::Collection} that supports set theory operations
-  module SetTheoryOperations
-
-    # the collection of elements present in both sets
-    def intersection(other)
-      self.class.from_a(to_a & other.to_a)
-    end
-
-    # the collection of all elements present in either set
-    def union(other)
-      self.class.from_a(to_a | other.to_a)
-    end
-
-    # the collection of elements from this set with any elements from the other set removed
-    def difference(other)
-      self.class.from_a(to_a - other.to_a)
-    end
-
-    # the collection of elements that are members of exactly one of the sets
-    def symmetric_difference(other)
-      union(other).difference( intersection(other) )
-    end
-
-    # the collection of elements that are not members of this set
-    # @note this method requires that the including class define the class method .all(), which returns the collection of all possible elements
-    def complement
-      self.class.all.difference(self)
-    end
-
-  end
-
-end

data/lib/mtk/transform/transposable.rb

@@ -1,14 +0,0 @@
-module MTK::Transform
-
-  # {Mappable} class whose elements can handle the :transpose message
-  module Transposable
-
-    # Transpose all elements upward by the given interval
-    # @param interval_in_semitones [Numeric] an interval in semitones
-    def transpose interval_in_semitones
-      map{|elem| elem + interval_in_semitones }
-    end
-
-  end
-
-end

data/spec/mtk/event_spec.rb

@@ -1,139 +0,0 @@
-require 'spec_helper'
-
-describe MTK::Event do
-
-  let(:intensity) { mf }
-  let(:duration) { 2.5 }
-  let(:event) { Event.new(intensity, duration) }
-
-  describe "#intensity" do
-    it "is the intensity used to create the Event" do
-      event.intensity.should == intensity
-    end
-
-    it "is a read-only attribute" do
-      lambda{ event.intensity = 0 }.should raise_error
-    end
-  end
-
-  describe "#duration" do
-    it "is the duration used to create the Event" do
-      event.duration.should == duration
-    end
-
-    it "is a read-only attribute" do
-      lambda{ event.duration = 0 }.should raise_error
-    end
-
-    it "is always positive (absolute value of the duration used to construct the Event)" do
-      Event.new(intensity, -duration).duration.should == duration
-    end
-  end
-
-  describe "#rest?" do
-    it "is true when the duration used to create the Event was negative" do
-      Event.new(intensity, -duration).rest?.should be_true
-    end
-
-    it "is false when the duration used to create the Event was positive" do
-      event.rest?.should be_false
-    end
-  end
-
-  describe "from_hash" do
-    it "constructs an Event using a hash" do
-      Event.from_hash({ :intensity => intensity, :duration => duration }).should == event
-    end
-  end
-
-  describe "#to_hash" do
-    it "is a hash containing all the attributes of the Event" do
-      event.to_hash.should == { :intensity => intensity, :duration => duration }
-    end
-  end
-
-  describe "#clone_with" do
-    it "clones the Event when given an empty hash" do
-      event.clone_with({}).should == event
-    end
-
-    it "creates an Event with the given :intensity, and the current Event's duration if not provided" do
-      event2 = event.clone_with :intensity => (intensity * 0.5)
-      event2.intensity.should == (intensity * 0.5)
-      event2.duration.should == duration
-    end
-
-    it "creates an Event with the given :duration, and the current Event's intensity if not provided" do
-      event2 = event.clone_with :duration => (duration * 2)
-      event2.intensity.should == intensity
-      event2.duration.should == (duration * 2)
-    end
-  end
-
-  describe '#scale_intensity' do
-    it 'multiplies @intensity by the argument' do
-      (event.scale_intensity 0.5).should == Event.new(intensity * 0.5, duration)
-    end
-    it 'does not affect the immutability of the Evebt' do
-      (event.scale_intensity 0.5).should_not == event
-    end
-  end
-
-  describe '#scale_duration' do
-    it 'multiplies @duration by the argument' do
-      (event.scale_duration 2).should == Event.new(intensity, duration*2)
-    end
-    it 'does not affect the immutability of the Event' do
-      (event.scale_duration 0.5).should_not == event
-    end
-  end
-
-  describe "#velocity" do
-    it "converts intensities in the range 0.0-1.0 to a MIDI velocity in the range 0-127" do
-      Event.new(0, 0).velocity.should == 0
-      Event.new(1, 0).velocity.should == 127
-    end
-    it "rounds to the nearest MIDI velocity" do
-      Event.new(0.5, 0).velocity.should == 64 # not be truncated to 63!
-    end
-  end
-
-  describe "#duration_in_pulses" do
-    it "converts beats to pulses, given pulses_per_beat" do
-      Event.new(0,1).duration_in_pulses(60).should == 60
-    end
-
-    it "rounds to the nearest pulse" do
-      Event.new(0,1.5).duration_in_pulses(59).should == 89
-    end
-
-    it "is always positive (uses absolute value of the duration used to construct the Event)" do
-      Event.new(intensity, -1).duration_in_pulses(60).should == 60
-    end
-  end
-
-  describe "#==" do
-    it "is true when the intensities and durations are equal" do
-      event.should == Event.new(intensity, duration)
-    end
-    it "is false when the intensities are not equal" do
-      event.should_not == Event.new(intensity * 0.5, duration)
-    end
-    it "is false when the durations are not equal" do
-      event.should_not == Event.new(intensity, duration * 2)
-    end
-  end
-
-  describe "#to_s" do
-    it "is the intensity and duration to 2-decimal places" do
-      Event.new(0.454545, 0.789789).to_s.should == "0.45, 0.79"
-    end
-  end
-
-  describe "#inspect" do
-    it "is the string values of intensity and duration" do
-      Event.new(0.454545, 0.789789).inspect.should == "0.454545, 0.789789"
-    end
-  end
-
-end

data/spec/mtk/helper/event_builder_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-describe MTK::Helper::EventBuilder do
-
-  EVENT_BUILDER = MTK::Helper::EventBuilder
-
-  let(:intensity) { EVENT_BUILDER::DEFAULT_INTENSITY }
-  let(:duration)  { EVENT_BUILDER::DEFAULT_DURATION }
-
-  def notes(*pitches)
-    pitches.map{|pitch| Note(pitch, intensity, duration) }
-  end
-
-
-  describe "#next" do
-    it "builds a single-note list from a single-pitch list argument" do
-      event_builder = EVENT_BUILDER.new [Pattern.Cycle(C4)]
-      event_builder.next.should == notes(C4)
-    end
-
-    it "builds a list of notes from any pitches in the argument" do
-      event_builder = EVENT_BUILDER.new [Pattern.Cycle(C4), Pattern.Cycle(D4)]
-      event_builder.next.should == notes(C4, D4)
-    end
-
-    it "builds a list of notes from pitch sets" do
-      event_builder = EVENT_BUILDER.new [ Pattern.Cycle( PitchSet(C4,D4) ) ]
-      event_builder.next.should == notes(C4, D4)
-    end
-
-    it "builds notes from pitch classes and a default_pitch, selecting the nearest pitch class to the previous pitch" do
-      event_builder = EVENT_BUILDER.new [Pattern.Sequence(C,G,B,Eb,D,C)], :default_pitch => D3
-      notes = []
-      loop do
-        notes << event_builder.next
-      end
-      notes.flatten.should == notes(C3,G2,B2,Eb3,D3,C3)
-    end
-
-    it "defaults to a starting point of C4 (middle C)" do
-      event_builder = EVENT_BUILDER.new [Pattern.Sequence(C4)]
-      event_builder.next.should == notes(C4)
-    end
-
-    it "builds notes from pitch class sets, selecting the neartest pitch classes to the previous/default pitch" do
-      pitch_class_sequence = Pattern::Sequence.new([PitchClassSet(C,G),PitchClassSet(B,Eb),PitchClassSet(D,C)])
-      event_builder = EVENT_BUILDER.new [pitch_class_sequence], :default_pitch => D3
-      event_builder.next.should == notes(C3,G3)
-      event_builder.next.should == notes(B3,Eb3)
-      event_builder.next.should == notes(D3,C3)
-    end
-
-    it "builds notes from by adding Numeric intervals in :pitch type Patterns to the previous Pitch" do
-      event_builder = EVENT_BUILDER.new [ Pattern.PitchSequence( C4, M3, m3, -P5) ]
-      nexts = []
-      loop { nexts << event_builder.next }
-      nexts.should == [notes(C4), notes(E4), notes(G4), notes(C4)]
-    end
-
-    it "builds notes from by adding Numeric intervals in :pitch type Patterns to all pitches in the previous PitchSet" do
-      event_builder = EVENT_BUILDER.new [ Pattern.PitchSequence( PitchSet(C4,Eb4), M3, m3, -P5) ]
-      nexts = []
-      loop { nexts << event_builder.next }
-      nexts.should == [notes(C4,Eb4), notes(E4,G4), notes(G4,Bb4), notes(C4,Eb4)]
-    end
-
-    it "builds notes from intensities" do
-      event_builder = EVENT_BUILDER.new [ Pattern.PitchCycle(C4), Pattern.IntensitySequence(mf, p, fff) ]
-      nexts = []
-      loop { nexts += event_builder.next }
-      nexts.should == [Note(C4, mf, duration), Note(C4, p, duration), Note(C4, fff, duration)]
-    end
-
-    it "builds notes from durations" do
-      event_builder = EVENT_BUILDER.new [ Pattern.PitchCycle(C4), Pattern.DurationSequence(1,2,3) ]
-      nexts = []
-      loop { nexts += event_builder.next }
-      nexts.should == [Note(C4, intensity, 1), Note(C4, intensity, 2), Note(C4, intensity, 3)]
-    end
-  end
-
-  describe "#rewind" do
-    it "resets the state of the EventBuilder" do
-      event_builder = EVENT_BUILDER.new [ Pattern.PitchSequence(C,P8) ]
-      event_builder.next.should == [Note(C4,intensity,duration)]
-      event_builder.next.should == [Note(C5,intensity,duration)]
-      event_builder.rewind
-      event_builder.next.should == [Note(C4,intensity,duration)]
-    end
-  end
-
-end