rhythmruby 0.1.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.midi
+*~

data/.project

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>rhythmruby</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+	</buildSpec>
+	<natures>
+		<nature>com.aptana.ruby.core.rubynature</nature>
+	</natures>
+</projectDescription>

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gem rhythmruby

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Luuk van der Velden
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,91 @@
+RhythmRuby: Midi rhythms through String manipulation 
+====================================================
+
+**Author**:         Luuk van der Velden, (Amsterdam, 2013)                                                                         
+**Website**:                                                                                                                      
+**Git**:            https://github.com/Lvelden/rhythmruby.git                                                                        
+
+Synopsis
+--------
+
+RhythmRuby enables the creation of midi rhythms, through string manipulation. 
+It provides methods for rhythm/string creation, parsing and writing to midi files.
+Ruby and MIDI based rhythm delight!
+
+Basics
+------
+
+**installation:** gem install rhythmruby
+
+**1. rhythm string** is a string consisting of two symbols,
+one for silence (default '-') and one for an event or hit (default '#'). An example:
+'#---#---#---#---', is read as one (drum) hit every three silences. 
+
+**2. rhythm snippets** are the building blocks of a rhythm string. The
+StringCompiler Class allows the creation of rhythm snippets and compiles them into a rhythm string.
+These snippets capture the repetitive aspects of most rhythms.
+
+**3. countBase** is the rhythmical length that is assigned to one symbol in a string.
+It is measured in quartenote lengths (relative to bpm), thus countBase: 1.0, means one quarter note per symbol. 
+
+Classes
+-------
+The **RhythmCompiler** (class) generates rhythm snippets and combines these into rhythm strings.
+These can be parsed to MIDI ready data by the **RhythmParser** (class).
+The parsed output can be written to a MIDI file by the **MidiWriter** (class instance). 
+
+Examples and Docs
+-----------------
+
+Check out the examples provided and the documentation based on YARD. The examples are aimed at 
+creating single and multi instrument rhythms. For instance **Meshuggah_example.rb** explains the creation of the
+intro rhythm of 'Perpetual Black Second' by Meshuggah (Nothing, 2002), using ruby scripting.
+
+
+**minimal example**
+
+In the example below we have skipped the creation of the rhythm string. 
+A predefined rhythm is written to midi.
+
+    require 'rhythmruby'
+    
+    midiNote = 50 # midi note assigned to drum hits
+    bpm = 120 # beats per minute of midi file
+    fileName = 'testing.midi' # name of midi file
+    
+    countBase = 1.0/4.0 # one symbol represents a sixteenth note (one fourth of a quarter note)
+        
+    rhythm = '#---#---' # two quarter note drum hits, on sixteenth note base
+    
+    # parse the rhythm string to MIDI ready information (array of [midiNote, noteLength] sub-arrays)
+    midiInfo = RhythmParser.parseRhythm(rhythm, countBase, midiNote)
+    
+    midiWriter = MidiWriter.new(bpm) # midiWriter instance administrating one MIDI song
+    midiTrack = midiWriter.createTrack() # create track in the MIDI song
+    midiWriter.writeSeqToTrack(midiInfo, midiTrack) # write the parsed rhythm to a MIDI track
+    midiWriter.writeToFile(fileName) # write MIDI song to file
+
+Workflow on Linux
+--------
+
+On linux the MIDI files created with rhythmruby can be played from the command-line by programs like
+pmidi. pmidi can send the MIDI events to any ALSA channel f.i. the MIDI-in of the Hydrogen sampler, which
+is a nice drum sampler and sequencer. In this way you can listen to the rhythms you create without leaving your
+IDE or editor.
+
+Rational
+--------
+
+RhythmRuby's strength lies in the rhythm string abstraction. It allows easy computer
+manipulation of rhythm snippets to create rhythm patterns. These can then be
+written to a midi file, possibly consisting of several tracks (f.i. hihat, snare, kick)
+
+With RhythmRuby you can capture polyrhythmics at their essence by creating patterns of rhythm snippets.
+The resulting MIDI files are perfect for further use in DAW's such as (cubase, logic, etc.)
+
+RhythmRuby was made to create drum rhythms for my band Hologram Earth (www.hologramearth.nl)
+
+Acknowledgment
+--------------
+thanks Jim Menard for **midilib**, a pure ruby MIDI library.
+https://github.com/jimm/midilib

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/examples/Meshuggah_example.rb

@@ -0,0 +1,91 @@
+# ruby version testing
+versionInfo = RUBY_VERSION.split('.').map{|num| num.to_i}
+
+if versionInfo[1]==9
+  require "rhythmruby"
+elsif versionInfo[1]<=8
+  require "rubygems"
+  require "rhythmruby"
+end
+
+# In this example we recreate the initial drum pattern of the song:
+#'Perpetual Black Second' by Meshuggah, as played on the album Nothing (2002)
+# hi-hat and snare are quite straightforward, but we will use
+# RhythmRuby to concisely capture the polyrhythmics in the kick pattern
+
+fileName = 'Meshuggah.midi'
+bpm = 140 # beats per minute of midi Song
+countBase = 1.0/4.0 # countbase in multiples/divisions of the quarternote (1/4 countbase is sixteenth notes, 4 notes per quarter note)
+
+# define midiNotes for the midi percussion tracks,
+# these default notes work with the Hydrogen sampler
+midiNotes = {'kick'=>36, 'snare'=>38, 'hihat'=>42}
+
+# empty hash to store rhythm parameters
+stringParam ={'kick'=>{}, 'snare'=>{}, 'hihat'=>{}}
+
+
+# create rhythm by specifying snippets and snippet patterns
+
+# basic quarter note beat on the hihat
+stringParam['hihat']['snippetL'] = [4] # snippet has length of 4 sixteenth notes (see countBase)
+stringParam['hihat']['eventPos'] = [[0]] # event/hit happens at position 0
+stringParam['hihat']['idx'] = [0] # only snippet '0' is repeated
+stringParam['hihat']['nRep'] = [32] # repeat the snippet 32 times (32 quarternotes)
+stringParam['hihat']['rhythmRep'] = 1 # repeat this rhythm once
+
+# snare pattern of four quarter note, snare on third quarter note
+stringParam['snare']['snippetL'] = [4,4] # two snippets of length 4 sixteenth notes
+stringParam['snare']['eventPos'] = [[], [0]] #. one snippet with hit on first sixteenth note and one empty snippet
+stringParam['snare']['idx'] = [0,0,1,0] # pattern of snippets (empty, empty, hit, empty)
+stringParam['snare']['nRep'] = nil # repeat snippets once
+stringParam['snare']['rhythmRep'] = 8 # repeat complete rhythm 8 times
+
+
+# interesting kick pattern of 14 sixteenth notes long, it shifts respective to the hi-hat
+# it can be understood as 7/8 (kick) over 4/4 (snare) polyrhythmic 
+stringParam['kick']['snippetL'] = [14, 2] # main pattern and 2 note filler at end
+
+# the main 14 sixteenth note snippet looks like this: #--#--#-##-#--
+stringParam['kick']['eventPos'] = [[0, 3, 6, 8, 9, 11],[0]] # positions at which hits/events occur per snippet
+stringParam['kick']['idx'] = [0,1] # sequential order of snippets, first repeat main snippet then add filler
+stringParam['kick']['nRep'] = [9,1] # repeat main snippet 9 times, then play filler pattern once
+stringParam['kick']['rhythmRep'] = 1 # repeat total rhythm once
+
+# for each instrument
+# create rhythm snippet strings and combine them in a rhythm string
+rhythms = {} # empty hash for storing rhythms per instrument
+stringParam.each_key do
+  |instr|
+  snippets = RhythmCompiler.createSnippets(stringParam[instr]['snippetL'],stringParam[instr]['eventPos'])
+  # compile rhythm pattern/string
+  rhythms[instr] = RhythmCompiler.createRhythm(snippets, stringParam[instr]['idx'], stringParam[instr]['nRep'], stringParam[instr]['rhythmRep'])
+
+end
+
+# print out the compiled rhythm
+puts 'rhythm'
+for instr in ['hihat','snare','kick']
+  puts rhythms[instr]
+end
+
+
+# create the midiWriter instance, to write the midi info to a file
+midiWriter = MidiWriter.new(bpm) # instance creates a midi song with a fixed bpm
+
+# parse and write rhythm to midi track for each instrument
+rhythms.each_key do
+  |instr|
+  # parse the string and return the midi info
+  midiSequence = RhythmParser.parseRhythm(rhythms[instr], countBase, midiNotes[instr])
+  
+  # create an empty midi track within the midiSong, to write the midi info to
+  midiTrack = midiWriter.createTrack()
+  
+  # write the midi info/sequence to the midiTrack
+  midiWriter.writeSeqToTrack(midiSequence, midiTrack)
+
+end
+
+# write the midiSong to a file
+midiWriter.writeToFile(fileName)

data/examples/drum_kit_example.rb

@@ -0,0 +1,80 @@
+# ruby version testing
+versionInfo = RUBY_VERSION.split('.').map{|num| num.to_i}
+
+if versionInfo[1]==9
+  require "rhythmruby"
+elsif versionInfo[1]<=8
+  require "rubygems"
+  require "rhythmruby"
+end
+
+fileName = 'drumtest.midi'
+bpm = 120 # beats per minute of midi Song
+countBase = 1.0/4.0 # countbase in multiples/divisions of the quarter note (1/4 countbase is sixteenth notes, 4 notes per quarter note)
+
+
+midiNotes = {'kick'=>36, 'snare'=>38, 'hihat'=>42}
+stringParam ={'kick'=>{}, 'snare'=>{}, 'hihat'=>{}}
+
+
+# parameters for rhythm composition
+
+# quarter note beat on the hi-hat
+stringParam['hihat']['snippetL'] = [4] # snippet is 4 siixteenthnotes long (one quarter note)
+stringParam['hihat']['eventPos'] = [[0]] # hi-hat hit is on the first sixteenth note (the beat)
+stringParam['hihat']['idx'] = [0] # rhythm is made up out of one snippet
+stringParam['hihat']['nRep'] = [8] # repeat snippet 30 times for 30 quarter notes
+stringParam['hihat']['rhythmRep'] = 1 # repeat total rhythm once for 8 beat bar
+
+
+# snare on two and four
+stringParam['snare']['snippetL'] = [4,4] # two snippets of 4 sixteenth notes
+stringParam['snare']['eventPos'] = [[],[0]] # two snippets, one has no hits, one has it on the first sixteenth note
+stringParam['snare']['idx'] = [0,1] # alternate the two snippets
+stringParam['snare']['nRep'] = nil # play snippets once before alternating
+stringParam['snare']['rhythmRep'] = 4 # repeat the two beat rhythm 4 times for 8 beat bar
+
+# kick on first two eight notes
+stringParam['kick']['snippetL'] = [4,4] # two snippets of length 4
+stringParam['kick']['eventPos'] = [[0,2],[]] # kick on first and third sixteenth note and empty snippet
+stringParam['kick']['idx'] = [0,1] # alternate the snippets
+stringParam['kick']['nRep'] = nil # play snippets once before alternating
+stringParam['kick']['rhythmRep'] = 4 # repeat rhythm 4 times for 8 beat bar
+
+# for each instrument
+# create rhythm snippet strings and combine them in a rhythm string
+rhythms = {} # empty hash for storing rhythms per instrument
+stringParam.each_key do
+  |instr|
+  snippets = RhythmCompiler.createSnippets(stringParam[instr]['snippetL'],stringParam[instr]['eventPos'])
+  # compile rhythm pattern/string
+  rhythms[instr] = RhythmCompiler.createRhythm(snippets, stringParam[instr]['idx'], stringParam[instr]['nRep'], stringParam[instr]['rhythmRep'])
+
+end
+
+# print out the compiled rhythm
+puts 'rhythm'
+for instr in ['hihat', 'snare', 'kick']
+  puts rhythms[instr]
+end
+
+
+# create the midiWriter instance, to write the midi info to a file
+midiWriter = MidiWriter.new(bpm) # instance creates a midi song with a fixed bpm
+
+# parse and write rhythm to midi track for each instrument
+rhythms.each_key do
+  |instr|
+  # parse the string and return the midi info
+  midiSequence = RhythmParser.parseRhythm(rhythms[instr], countBase, midiNotes[instr])
+  
+  # create an empty midi track within the midiSong, to write the midi info to
+  midiTrack = midiWriter.createTrack()
+  
+  # write the midi info/sequence to the midiTrack
+  midiWriter.writeSeqToTrack(midiSequence, midiTrack)
+
+end
+
+# write the midiSong to a file
+midiWriter.writeToFile(fileName)

data/examples/single_rhythm_example.rb

@@ -0,0 +1,51 @@
+# ruby version testing
+versionInfo = RUBY_VERSION.split('.').map{|num| num.to_i}
+
+if versionInfo[1]==9
+  require "rhythmruby"
+elsif versionInfo[1]<=8
+  require "rubygems"
+  require "rhythmruby"
+end
+
+fileName = 'test.midi'
+bpm = 140 # beats per minute of midi Song
+midiNote = 46 # midiNote of events, we are testing with one instrument, so one note
+countBase = 1.0/4.0 # countbase in multiples/divisions of the quarter note (1/4 countbase is sixteenth notes, 4 notes per quarter note)
+
+# note 36=kick, 38=snare 46=hi-hat
+
+# snippet creation parameters
+snippetLengths = [4] # length per snippet (or length for all snippets, if snippeLength.length == 1)
+eventPositions = [[0]] # positions per snippet, where events happen (zero-based)
+
+# pattern creation parameters
+snippetIdx = [0] # indexes of snippets to be added sequentially to the rhythm string
+snippetRep = [10] # number of repeats per snippet, if undefined (nil) all snippets are repeated once 
+totalRepeat = 1 # repeat total rhythm once
+
+# create rhythm snippet strings
+snippets = RhythmCompiler.createSnippets(snippetLengths, eventPositions)
+
+puts 'snippets', snippets
+
+# compile rhythm pattern/string
+rhythm = RhythmCompiler.createRhythm(snippets, snippetIdx, snippetRep, totalRepeat)
+
+# print out the compiled rhythm
+puts 'rhythm', rhythm
+
+# parse the string and return the midi info
+midiSequence = RhythmParser.parseRhythm(rhythm, countBase, midiNote)
+
+# create the midiWriter instance, to write the midi info to a file
+midiWriter = MidiWriter.new(bpm)
+
+# create an empty midi track within the midiSong, to write the midi info to
+midiTrack = midiWriter.createTrack()
+
+# write the midi info/sequence to the midiTrack
+midiWriter.writeSeqToTrack(midiSequence, midiTrack)
+
+# write the midiSong to a file
+midiWriter.writeToFile(fileName)

data/lib/rhythmruby.rb

@@ -0,0 +1,5 @@
+# main file to load seperate class files
+
+require "rhythmruby/RhythmParser"
+require "rhythmruby/RhythmCompiler"
+require "rhythmruby/MidiWriter"  

data/lib/rhythmruby/MidiWriter.rb

@@ -0,0 +1,60 @@
+# ruby version testing
+versionInfo = RUBY_VERSION.split('.').map{|num| num.to_i}
+
+# MIDI interface was build on midilib, by Jim Menard, https://github.com/jimm/midilib
+if versionInfo[1]==9
+  require "midilib"
+elsif versionInfo[1]<=8
+  require "rubygems" 
+  require "midilib"  
+end
+
+# writes sequences of noteData (from a RhythmParser class) to midi tracks
+# a 'MidiWriter' represents one midi Song, which can be written to one file,
+# the midiSong can contain multiple tracks/noteSequences
+#
+# @param [Float] bpm beats per minute of the midi song/file that the tracks are part of
+# @return [Object] MidiWriteInstance instance of the midi writer.
+#   creator of one midi file with potential multiple tracks
+class MidiWriter
+  def initialize(bpm)
+    @song = MIDI::Sequence.new() # this is a midi song/sequence
+    @bpm = bpm # beats per minute of the midi song/sequence
+  end  
+  
+  # creates a track within the midi song of current MidiWriter instance
+  # @return [MIDI::Track] newTrack a new track within the midi song
+  def createTrack()
+     @song.tracks << (newTrack = MIDI::Track.new(@song))
+     newTrack.events <<  MIDI::Tempo.new(MIDI::Tempo.bpm_to_mpq(@bpm))
+     newTrack.events << MIDI::ProgramChange.new(0, 0)
+     return newTrack
+  end
+  
+  # writes a note sequence generate by a RhythmParser to a midi track
+  # @param [Array<Array>] midiSeq an array of [midiNote, noteLength] (created by RhythmParser)
+  # @param [MIDI:Track] midiTrack target track, generated with 'createTrack'.
+  #   if a track is reused the event sequence will be appended
+  def writeSeqToTrack(midiSeq, midiTrack)
+    midiSeq.each do
+      |midiNote, noteLength|    
+      writeNote(midiNote, noteLength, midiTrack)
+    end
+  end
+  
+  # writes one midiNote to a midiTrack
+  # @param [Fixnum] midiNote of the event to be written to a midiTrack
+  # @param [Float] noteLength length of the midiEvent, in multiples of the quarternote
+  # @param [MIDI::Track] midiTrack where the event is written to
+  def writeNote(midiNote, noteLength, midiTrack)
+      midiTrack.events << MIDI::NoteOnEvent.new(0, midiNote, 127, 0) 
+      midiTrack.events << MIDI::NoteOffEvent.new(0, midiNote, 127, \
+      @song.length_to_delta(noteLength))
+  end
+
+  # write the midiSong to file consisting of all the created midiTracks
+  # @param [String] fileName where the midiSong is written to, can be a path 
+  def writeToFile(fileName)
+    open(fileName, 'w') {|f| @song.write(f) }
+  end
+end

data/lib/rhythmruby/RhythmCompiler.rb

@@ -0,0 +1,78 @@
+
+# rhythm composition class (use as a class)
+# compiles rhythm snippets into a rhythm string/pattern
+class RhythmCompiler
+  @@silenceMarker = '-' # symbol for silence
+  @@eventMarker = '#' # symbol for an event / hit
+  
+  # create an array of snippets of length in snippetLengths,
+  # with events at position(s) in eventPositions
+  # @param [Array<Fixnum>] snippetLengths length of each snippet
+  #   (if snippetLengths.length == 1, length is constant for all snippets )
+  # @param [Array<Array>] eventPositions containing arrays of event positions per snippet 
+  #   (if eventPositions.length == 1, then event positions are constant for all snippets)
+  # @return [Array<String>] snippets array of string rhythm snippets,
+  #   for use with 'createString' method  
+  def self.createSnippets(snippetLengths, eventPositions)
+    snippets = [] # empty array to append the snippets
+    
+    # make input arrays suitable for fur
+    if snippetLengths.length == 1
+      # make snippetLengths as long as eventPositions      
+      snippetLengths *= eventPositions.length 
+             
+    elsif eventPositions.length == 1 
+     # make eventPositions as long as snippetLengths 
+     eventPositions *= snippetLengths.length 
+     
+    else # both input arrays have more than one element and should be the same length
+      if not(eventPositions.length == snippetLengths.length)
+        raise ArgumentError, 'lengths of both arrays should be the same, \
+         or one should have length 1'
+      end
+    end    
+    
+    #create a rhythm snippet for each set of event positions and snippetlength
+    snippetLengths.zip(eventPositions).each do  
+        |length, positions| # unpack the length and position information   
+        # create a snippet of defined length consisting of silences
+        snippet = @@silenceMarker*length 
+                
+        positions.each{|pos| # for each provided event positon of the snippet
+          snippet[pos] = @@eventMarker # add an event marker at the position
+        }
+        
+        snippets<<snippet # add the snippet to the returned snippets array
+     end   
+     return snippets # return the array with the snippets
+  end
+  
+  # creates a rhythm string from rhythm snippets
+  # @param [Array<String>] snippets array of rhythm snippets (from 'createSnippets)
+  # @param [Array<Fixnum>] snippetIDx indexes, defining sequential order of snippets
+  # @param [Array<Fixnum>] snippetRep defining how often snippets are repeated...
+  #   if nil, all snippets are repeated once, if snippetRep.length==1, all snippets are repeated the same amount
+  #   otherwise snippetRep should be the same length as snippetIdx and define repetition per snippet
+  # @param [Fixnum] totalRepeat, number of times the total rhythm is repeated
+  # @return [String] rhythmString, symbolic rhythm string
+  def self.createRhythm(snippets, snippetIDx, snippetRep, totalRepeat)
+    if snippetRep == nil # test whether snippetRep is defined, if not all snippets are repeated once
+      snippetRep = [1]*snippetIDx.length # make snippetRep and snippetIDx the same length for iteration
+    end 
+    if totalRepeat == nil # if undefined set repeats equal to 1
+      totalRepeat = 1
+    end
+    
+    
+    rhythmString = "" # empty string where all the snippets will be added to
+    
+    # iterate over combinations of snippetID and repeats
+    snippetIDx.zip(snippetRep).each do
+      |snippetID, repeats|
+      # add the snippet with snippetID, repeat times, to the rhythm string 
+      rhythmString += snippets[snippetID]*repeats 
+    end
+    
+    return rhythmString*totalRepeat # return the rhythm string repeated totalRepeat times, ready for parsing
+  end
+end

data/lib/rhythmruby/RhythmParser.rb

@@ -0,0 +1,59 @@
+
+# Parser (use as class) of the rhythm strings, consisting event and silence symbols
+class RhythmParser
+  @@silenceNote = 1 # pitch of a note played at during initial silence in a sequence
+  @@silenceMark = '-' # symbol identified as a silence
+  @@eventMark = '#' # symbol identified as an event
+  @@eventNote = 50 # (unused default) midi note of an event
+  @@countBase = 1.0/4.0 # (unused default) time duration of one symbol in quarter note lengths
+  
+  # parses the rhythm string and generates midi info ready for MidiWriter
+  # side note:  a string starting with a silence needs an initial 'silence note' (note value: @@silenceNote)
+  # @param [String] rhythmString sequence of silence and event markers
+  # @param [Float] countBase rhyhtmic length of one symbol (in quarternote units)
+  # @param [Fixnum] midiNote note assigned to events in the parsed output
+  # @return [Array<Array>] midiSequence array of [midiNote, noteLength]
+  #   can be written to midi with midiWriter.writeSegToTrack
+  def self.parseRhythm(rhythmString, countBase, midiNote)
+    @@countBase = countBase # time duration of one symbol (quarternote lengths)
+    @@eventNote = midiNote # midi note assigned to events
+    
+    midiSequence = [] # empty array to store parsed midi data
+    curNote = nil # initialize current midi note
+    curLen = nil  # initialze current midi note length
+    first = true # state variable testing for first / sequential events
+    
+    rhythmString.each_char do
+      |symbol| # symbol in the string either a silence or an event
+      
+      if first # if true this is the first parsed symbol
+        first = false # skip on next symbol
+        
+        # if first symbol is an event (handles when the rhythm starts with a silence)
+        if symbol == @@eventMark 
+          curNote = @@eventNote
+          curLen = 1
+          
+        elsif symbol == @@silenceMark
+          curNote = @@silenceNote
+          curLen = 1
+          
+        end 
+      else # when first symbol has already been parsed
+        if symbol == @@eventMark # an event is parsed, write previous event and generate new one
+            # add midi event to midiSequence (note length in countbase units)
+            midiSequence << [curNote,(curLen*@@countBase)] 
+            curNote = @@eventNote # generate new event
+            curLen = 1 # reset note length to 1
+          
+        elsif symbol == @@silenceMark # a silence is parsed
+          curLen += 1 # add one countbase note length to the current note
+        
+       end
+     end
+    end
+    
+    return midiSequence
+  end
+end
+

data/lib/rhythmruby/version.rb

@@ -0,0 +1,3 @@
+module Rhythmruby
+  VERSION = "0.1.1"
+end

data/rhythmruby.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rhythmruby/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "rhythmruby"
+  gem.version       = Rhythmruby::VERSION
+  gem.authors       = ["Luuk van der Velden"]
+  gem.email         = ["l.j.j.vandervelden@gmail.com"]
+  gem.description   = %q{represent rhythms as symbolic Strings and write them to MIDI}
+  gem.summary       = %q{represent rhythms as symbolic Strings and write them to MIDI}
+  gem.homepage      = "https://github.com/Lvelden/rhythmruby"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_dependency 'midilib'
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: rhythmruby
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Luuk van der Velden
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: midilib
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: represent rhythms as symbolic Strings and write them to MIDI
+email:
+- l.j.j.vandervelden@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .project
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/Meshuggah_example.rb
+- examples/drum_kit_example.rb
+- examples/single_rhythm_example.rb
+- lib/rhythmruby.rb
+- lib/rhythmruby/MidiWriter.rb
+- lib/rhythmruby/RhythmCompiler.rb
+- lib/rhythmruby/RhythmParser.rb
+- lib/rhythmruby/version.rb
+- rhythmruby.gemspec
+homepage: https://github.com/Lvelden/rhythmruby
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: represent rhythms as symbolic Strings and write them to MIDI
+test_files: []
+has_rdoc: