teejayvanslyke-clef 0.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 teejayvanslyke
+
+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.rdoc

@@ -0,0 +1,24 @@
+= clef
+=== An Interactive Music Experience Beyond Your Wildest Imagination!
+===  By Mister Teejay VanSlyke!
+
+== Getting Started!
+
+Clef is an interactive music programming language.  To install, type 
+
+    sudo gem install teejayvanslyke-clef  # that's me!
+
+Clef is a client-server application.  Ooooh.  It's so fancy.  That means 
+you'll want to type
+
+    clef_server
+
+in one terminal window, and
+
+    clef
+
+in another!  
+
+== Copyright
+
+Copyright (c) 2009 teejayvanslyke. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "clef"
+    gem.summary = %Q{TODO}
+    gem.email = "tj@elctech.com"
+    gem.homepage = "http://github.com/teejayvanslyke/clef"
+    gem.authors = ["teejayvanslyke"]
+    gem.add_dependency('gamelan')
+    gem.add_dependency('midiator')
+    gem.add_dependency('treetop')
+    gem.add_dependency('andand')
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "clef #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 0
+:patch: 0

data/bin/clef

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/clef'
+
+DRb.start_service
+Clef::Console.new.run
+DRb.stop_service

data/bin/clef_server

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/clef'
+
+environment = Clef::Environment.new
+
+puts "Starting Clef server..."
+DRb.start_service('druby://localhost:12345', environment)
+puts "Listening at #{DRb.uri}."
+
+environment.run
+
+DRb.thread.join
+

data/lib/clef.rb

@@ -0,0 +1,47 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+gem     'treetop'
+require 'treetop'
+
+gem     'andand'
+require 'andand'
+
+require 'midiator'
+require 'gamelan'
+require 'drb'
+
+Treetop.load File.dirname(__FILE__) + '/clef'
+
+require 'core_ext/fixnum'
+
+require 'clef/utils'
+require 'clef/note'
+require 'clef/rest'
+require 'clef/harmony'
+require 'clef/sequence'
+require 'clef/environment'
+require 'clef/channel'
+require 'clef/console'
+
+module Clef
+
+  def self.parse(expr)
+    @parser ||= ClefParser.new
+    @parser.parse(expr)
+  end
+
+  def self.evaluate(expr)
+    self.parse(expr).andand.evaluate(self.environment)
+  end
+
+  def self.last_failure
+    @parser.failure_reason
+  end
+
+  def self.environment
+    DRbObject.new(nil, 'druby://localhost:12345')
+  end
+
+end

data/lib/clef.treetop

@@ -0,0 +1,202 @@
+grammar Clef
+
+  rule statement
+    assignment / expression
+  end
+  
+  rule expression
+    additive
+  end
+
+  rule assignment
+    channel 
+    space '=' space
+    expression {
+      def evaluate(env)
+        env.play(channel.evaluate(env).to_i, expression.evaluate(env))
+      end
+    }
+  end
+
+  rule additive
+    operand1:multitive
+    space operator:additive_operator space
+    operand2:additive {
+      def evaluate(env)
+        operator.apply(operand1.evaluate(env), operand2.evaluate(env))
+      end
+    }
+    /
+    multitive
+  end
+
+  rule additive_operator
+    '+' {
+      def apply(a, b)
+        a + b
+      end
+    }
+    / 
+    '-' {
+      def apply(a, b)
+        a - b
+      end
+    }
+  end
+
+  rule multitive
+    operand1:primary
+    space operator:multitive_operator space
+    operand2:multitive {
+      def evaluate(env)
+        operator.apply(operand1.evaluate(env), operand2.evaluate(env))
+      end
+    }
+    /
+    primary
+  end
+
+  rule multitive_operator
+    '*' {
+      def apply(a, b)
+        a * b
+      end
+    }
+    /
+    '/' {
+      def apply(a, b)
+        a / b
+      end
+    }
+    /
+    '&' {
+      def apply(a, b)
+        a & b
+      end
+    }
+  end
+
+  rule primary
+    sequence 
+    / 
+    integer
+    /
+    channel
+    /
+    '(' space expression space ')' { 
+      def evaluate(env)
+        expression.evaluate(env)
+      end
+    }
+  end
+
+  rule sequence
+    '[' playables ']' {
+      def evaluate(env)
+        Clef::Sequence.new(playables.evaluate(env))
+      end
+    }
+  end
+
+  rule key
+    [A-Ga-g] { 
+      def evaluate(env)
+        text_value
+      end
+    }
+  end
+
+  rule accent
+    ('-' / '#') {
+      def evaluate(env)
+        text_value
+      end
+    }
+  end
+
+  rule integer
+    '-'? [0-9]+ {
+      def evaluate(env)
+        text_value.to_i
+      end
+    }
+  end
+
+  rule octave
+    [0-9] {
+      def evaluate(env)
+        text_value.to_i
+      end
+    }
+  end
+
+  rule note
+    key accent octave {
+      def evaluate(env)
+        Clef::Note.new(
+          key.evaluate(env), 
+          accent.evaluate(env), 
+          octave.evaluate(env))
+      end
+    }
+    /
+    rest
+  end
+
+  rule notes 
+    note space notes {
+      def evaluate(env)
+        [ note.evaluate(env), notes.evaluate(env) ].flatten
+      end
+    }
+    /
+    note
+  end
+
+  rule rest
+    '_'+ {
+      def evaluate(env)
+        Clef::Rest.new
+      end
+    }
+  end
+
+  rule harmony 
+    '(' space notes space ')' {
+      def evaluate(env)
+        Harmony.new(notes.evaluate(env))
+      end
+    }
+  end
+
+  rule playable
+    note / harmony
+  end
+
+  rule playables
+    playable space playables {
+      def evaluate(env)
+        [ playable.evaluate(env), playables.evaluate(env) ].flatten
+      end
+    }
+    /
+    playable
+  end
+
+  rule channel_number
+    '0' / '1' / '2' / '3' / '4' / '5' / '6' / '7' / '8' / '9' / '10' / '11' / '12' / '13' / '14' / '15'
+  end
+
+  rule channel
+    '@' channel_number {
+      def evaluate(env)
+        env.channels[channel_number.text_value.to_i]
+      end
+    }
+  end
+
+  rule space
+    ' '*
+  end
+
+end

data/lib/clef/channel.rb

@@ -0,0 +1,39 @@
+module Clef
+
+  class Channel
+
+    def initialize(number)
+      @number     = number
+      @expression = Sequence.new([])
+    end
+
+    def play(expression)
+      @expression = expression
+    end
+
+    def to_s
+      @expression.to_s
+    end
+
+    def to_i
+      @number
+    end
+
+    def schedule(environment)
+      puts "Scheduling channel #{self.to_i} on #{environment}"
+      @expression.each_with_index do |playable, time|
+        if Harmony === playable
+          playable.each do |note|
+            environment.schedule_note_on(time, note.to_i, self.to_i, 127)
+          end
+        else
+          environment.schedule_note_on(time, playable.to_i, self.to_i, 127)
+        end
+      end
+    end
+
+  end
+
+end
+
+

data/lib/clef/console.rb

@@ -0,0 +1,42 @@
+require 'readline'
+
+module Clef
+
+  class Console
+
+    def run
+
+      puts "Clef."
+      puts "An algorithmic music language."
+      puts "By T.J. VanSlyke."
+      puts "\n"
+
+      loop do
+        begin
+          line = Readline::readline('$>> ')
+
+          if line.nil?
+            puts "\nExiting..."
+            exit
+          end
+
+          Readline::HISTORY.push(line)
+
+          result = Clef.evaluate(line)
+
+          if result.nil?
+            puts "Clef didn't understand '#{line}': #{Clef.last_failure}"
+          else
+            puts "=> #{result.to_s}"
+          end
+        rescue => e
+          puts "There was a system error:  #{e}"
+        end
+      end
+
+    end
+
+  end
+
+end
+

data/lib/clef/environment.rb

@@ -0,0 +1,145 @@
+module Clef
+
+  class Environment
+
+    attr_reader :channels
+
+    def initialize
+      initialize_channels
+      initialize_midi
+    end
+
+    def run
+      schedule_events
+      @scheduler.run
+    end
+
+    def tempo=(tempo)
+      @scheduler.tempo = tempo
+    end
+
+    def play(channel, expression)
+      channels[channel].play(expression)
+    end
+
+    def schedule_note_on(time, pitch, channel, velocity)
+      @scheduler.at(@time + time) { @midi.note_on(pitch,channel,velocity) }
+    end
+
+    private
+
+    def initialize_channels
+      @channels = []
+      16.times {|i| @channels << Channel.new(i) }
+    end
+
+    def initialize_midi
+      @events   = {}
+
+      @time  = 0
+      @beats = 16
+
+      @midi = MIDIator::Interface.new
+      @midi.use(:dls_synth)
+
+      @midi.control_change(32, 10, 1)
+      @midi.program_change(10, 26)
+
+      @scheduler = Gamelan::Scheduler.new({:tempo => 180})
+    end
+
+    def schedule_events
+      @channels.each do |channel|
+        channel.schedule(self)
+      end
+
+      @time = @time + @beats
+
+      @scheduler.at(@time) do
+        schedule_events
+      end
+    end
+
+  end
+
+end
+
+=begin
+module Spieluhr
+
+  module Engine
+
+    class Sequencer
+
+      attr_reader :events
+
+      def initialize
+        @events   = {}
+
+        @time  = 0
+        @beats = 16
+
+        @midi = MIDIator::Interface.new
+        @midi.use(:dls_synth)
+
+        @midi.control_change(32, 10, 1)
+        @midi.program_change(10, 26)
+
+        @scheduler = Gamelan::Scheduler.new({:tempo => 180})
+      end
+
+      def beats
+        @beats
+      end
+
+      def self.current
+        DRbObject.new(nil, 'druby://localhost:12345')
+      end
+
+      def push(patch, line)
+        @events[patch] ||= []
+        @current_patch = patch
+        patch.block.call(patch.parameters(line))
+      end
+
+      def schedule(time)
+        @scheduler.at(@time + time) { yield self }
+      end
+
+      def tempo=(tempo)
+        @scheduler.tempo = tempo
+      end
+
+      def play(options)
+        event = Event.new(self, options)
+        @events[@current_patch] << event
+        event
+      end
+
+      def note_on(pitch, channel, velocity)
+        @midi.note_on(pitch,channel,velocity)
+      end
+
+      def schedule_events
+        @events.values.flatten.each do |event|
+          event.schedule(self)
+        end
+
+        @time = @time + @beats
+
+        @scheduler.at(@time) do
+          schedule_events
+        end
+      end
+
+      def run
+        schedule_events
+        @scheduler.run
+      end
+
+    end
+
+  end
+
+end
+=end

data/lib/clef/harmony.rb

@@ -0,0 +1,38 @@
+require 'set'
+
+module Clef
+
+  class Harmony < Set
+
+    def initialize(elements)
+      notes = []
+      elements.each do |e|
+        if Harmony === e
+          notes += e.to_a
+        else
+          notes << e
+        end
+      end
+
+      super(notes.compact.uniq)
+    end
+
+    def to_s
+      if size == 1
+        map {|n| n.to_s}.join(' ')
+      else
+        "(#{sort.map {|n| n.to_s}.join(' ')})"
+      end
+    end
+
+    def +(rhs)
+      if rhs.is_a?(Fixnum)
+        Harmony.new(map {|n| n + rhs})
+      else 
+        super(rhs)
+      end
+    end
+
+  end
+
+end

data/lib/clef/matrix.rb

@@ -0,0 +1,21 @@
+require 'set'
+
+module Clef
+
+  class Matrix < Array
+
+    include Clef::Utils
+
+    def initialize(sequences)
+      return unless sequences.is_a?(Array) && sequences.size > 0
+      rotate_matrix(sequences, :right)
+      map! {|row| row.compact.uniq }
+    end
+
+    def to_s
+      "[#{map {|row| "(#{row.sort.map {|n| n.to_s}.join(' ')})"}.join(' ')}]"
+    end
+
+  end
+
+end

data/lib/clef/note.rb

@@ -0,0 +1,53 @@
+module Clef
+
+  class Note
+
+    NOTES = %w(C- C# D- D# E- F- F# G- G# A- A# B-)
+
+    attr_reader :octave
+
+    def initialize(key, accent, octave)
+      @key, @accent, @octave = key, accent, octave
+    end
+
+    def to_s
+      "#{@key}#{@accent}#{@octave}"
+    end
+
+    def +(rhs)
+      Clef::Note.from_i(to_i + rhs)
+    end
+
+    def -(rhs)
+      Clef::Note.from_i(to_i - rhs)
+    end
+
+    def self.from_i(integer)
+      key = NOTES[integer % 12]
+      octave = (integer / 12).to_i
+      new(key[0..0], key[1..1], octave)
+    end
+
+    def to_i
+      NOTES.index("#{@key.upcase}#{@accent}") + (octave * 12)
+    end
+
+    def sharp?
+      @accent == '#'
+    end
+
+    def <=>(rhs)
+      self.to_i <=> rhs.to_i
+    end
+
+    def ==(rhs)
+      if rhs === Note
+        to_s == rhs.to_s
+      elsif rhs.is_a?(String)
+        to_s == rhs
+      end
+    end
+
+  end
+
+end

data/lib/clef/rest.rb

@@ -0,0 +1,27 @@
+module Clef
+
+  class Rest < Note
+    def initialize
+      super(nil, nil, nil)
+    end
+
+    def to_s
+      '___'
+    end
+
+    def to_i
+      -1
+    end
+
+    def +(rhs)
+      self
+    end
+
+    def -(rhs)
+      self
+    end
+
+  end
+
+end
+

data/lib/clef/sequence.rb

@@ -0,0 +1,41 @@
+module Clef
+
+  class Sequence < Array
+
+    include Clef::Utils
+
+    def initialize(elements)
+      elements = [ elements ] unless elements.is_a?(Array)
+      super(elements)
+    end
+
+    def +(rhs)
+      Sequence.new(map {|note| note + rhs})
+    end
+
+    def &(rhs)
+      sequences = [ self, rhs ] 
+      sequences = rotate_matrix(sequences, :right)
+      Sequence.new(sequences.map {|row| Harmony.new(row)})
+    end
+
+    def -(rhs)
+      Sequence.new(map {|note| note - rhs})
+    end
+
+    def /(rhs)
+      result = []
+      each do |note|
+        result << note
+        (rhs-1).times { result << Rest.new }
+      end
+      Sequence.new(result)
+    end
+
+    def to_s
+      "[#{map {|n| n.to_s}.join(' ')}]"
+    end
+
+  end
+
+end

data/lib/clef/utils.rb

@@ -0,0 +1,39 @@
+module Clef
+
+  module Utils
+    # Adapted from http://snippets.dzone.com/posts/show/3404
+    def rotate_matrix(matrix, direction)
+      # - You must Rotate the matrix neo!
+      oldMap = matrix
+
+      map = []
+
+      # Get the number of lines in the old map (they're the new columns)
+      lineCount = oldMap.size
+      # Get the number of columns in the old map (We have that many rows now)
+      columnCount = oldMap[0].size
+      columnCount.times { map.push [] }
+
+      # Loop through every line in the old map, retrieve the appropriate column
+      # and make a horizontal column with it's contents
+      # we'll take one (old)line at a time and rotate it.
+      onLine = 0
+      oldMap.each do |oldLine|
+        onColumn = 0
+        oldLine.each do
+          case direction
+          when :right
+            map[(columnCount - 1) - onColumn][(lineCount - 1) - onLine] = oldLine[(columnCount - 1) - onColumn]
+          when :left
+            map[onColumn][onLine] = oldLine[(columnCount - 1) - onColumn]
+          end
+          onColumn += 1
+        end
+        onLine += 1
+      end
+      map
+    end
+  end
+
+end
+

data/lib/core_ext/fixnum.rb

@@ -0,0 +1,22 @@
+class Fixnum
+
+  alias :__clef__plus__ :+
+  alias :__clef__asterisk__ :*
+
+  def +(rhs)
+    if rhs.is_a?(Clef::Sequence)
+      rhs + self
+    else
+      __clef__plus__(rhs)
+    end
+  end
+
+  def *(rhs)
+    if rhs.is_a?(Clef::Sequence)
+      rhs * self
+    else
+      __clef__asterisk__(rhs)
+    end
+  end
+
+end

data/spec/clef/note_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Clef::Note do
+
+  describe '- When transposing' do
+    (Clef::Note.from_i(60) + 12).to_i.should == 72
+  end
+
+end

data/spec/clef_spec.rb

@@ -0,0 +1,227 @@
+require 'spec_helper'
+
+describe Clef do
+
+  describe '- When evaluating a sequence of notes' do
+    
+    def do_evaluate
+      Clef.evaluate('[C-4 C#4 D-4 E-4]')
+    end
+
+    it 'should return a Sequence instance' do
+      do_evaluate.should be_instance_of(Clef::Sequence)
+    end
+
+    it 'should have four elements' do
+      do_evaluate.size.should == 4
+    end
+
+    it 'should have all elements in order' do
+      %w(C-4 C#4 D-4 E-4).each_with_index do |note, index|
+        do_evaluate[index].to_s.should == note
+      end
+    end
+
+  end
+
+  describe '- When evaluating a sequence of notes with rests' do
+    
+    def do_evaluate
+      Clef.evaluate('[C-4 C#4 ___ D-4 E-4]')
+    end
+
+    it 'should have five elements' do
+      do_evaluate.size.should == 5
+    end
+
+    it 'should have all elements in order' do
+      %w(C-4 C#4 ___ D-4 E-4).each_with_index do |note, index|
+        do_evaluate[index].to_s.should == note
+      end
+    end
+
+    it 'should have a rest object in the appropriate position' do
+      do_evaluate[2].should be_instance_of(Clef::Rest)
+    end
+
+  end
+
+  describe '- When transposing (+) a sequence of notes' do
+
+    describe 'from the left-hand side' do
+
+      def do_evaluate
+        Clef.evaluate('[C-4 C#4] + 12')
+      end
+
+      it 'should have the same number of elements as the original' do
+        do_evaluate.size.should == 2
+      end
+
+      it 'should transpose the notes by the modifier' do
+        do_evaluate[0].should == 'C-5'
+        do_evaluate[1].should == 'C#5'
+      end
+
+    end
+
+    describe 'from the right-hand side' do
+
+      def do_evaluate
+        Clef.evaluate('12 + [C-4 C#4]')
+      end
+
+      it 'should have the same number of elements as the original' do
+        do_evaluate.size.should == 2
+      end
+
+      it 'should transpose the notes by the modifier' do
+        do_evaluate[0].should == 'C-5'
+        do_evaluate[1].should == 'C#5'
+      end
+
+    end
+
+  end
+
+  describe '- When transposing (-) a sequence of notes' do
+
+    describe 'from the left-hand side' do
+
+      def do_evaluate
+        Clef.evaluate('[C-4 C#4] - 2')
+      end
+
+      it 'should have the same number of elements as the original' do
+        do_evaluate.size.should == 2
+      end
+
+      it 'should transpose the notes by the modifier' do
+        do_evaluate[0].should == 'A#3'
+        do_evaluate[1].should == 'B-3'
+      end
+      
+    end
+
+    describe 'from the right-hand side' do
+
+      def do_evaluate
+        Clef.evaluate('-2 + [C-4 C#4]')
+      end
+
+      it 'should have the same number of elements as the original' do
+        do_evaluate.size.should == 2
+      end
+
+      it 'should transpose the notes by the modifier' do
+        do_evaluate[0].should == 'A#3'
+        do_evaluate[1].should == 'B-3'
+      end
+      
+    end
+
+  end
+
+  describe '- When transposing a sequence of notes with rests' do
+    it 'should leave the rests alone' do
+      Clef.evaluate('[C-3 ___] + 12').to_s.should == '[C-4 ___]'
+    end
+  end
+
+  describe '- When repeating (*) a sequence of notes' do
+
+    describe 'from the left-hand side' do
+
+      def do_evaluate
+        Clef.evaluate('[C-4 __] * 4')
+      end
+
+      it 'should be a repeated sequence of notes' do
+        do_evaluate.to_s.should == '[C-4 ___ C-4 ___ C-4 ___ C-4 ___]'
+      end
+
+    end
+
+    describe 'from the right-hand side' do
+
+      def do_evaluate
+        Clef.evaluate('2 * [C-4 __]')
+      end
+
+      it 'should be a repeated sequence of notes' do
+        do_evaluate.to_s.should == '[C-4 ___ C-4 ___]'
+      end
+
+    end
+
+  end
+
+  describe '- When rest-padding (/) a sequence of notes' do
+
+    describe 'from the left-hand side' do
+
+      it 'should insert the appropriate number of rests' do
+        Clef.evaluate('[C-4] / 4').to_s.should == '[C-4 ___ ___ ___]'
+        Clef.evaluate('[C-4 ___] / 4').to_s.should == '[C-4 ___ ___ ___ ___ ___ ___ ___]'
+        Clef.evaluate('[C-4 ___ C#4 ___ C-4 ___] / 4').to_s.should ==
+          '[C-4 ___ ___ ___ ___ ___ ___ ___ C#4 ___ ___ ___ ___ ___ ___ ___ C-4 ___ ___ ___ ___ ___ ___ ___]'
+      end
+
+    end
+
+  end
+
+  describe '- When combining two sequences into a matrix' do
+
+    def do_evaluate
+      Clef.evaluate('[C-4] & [C#4]')
+    end
+
+    it 'should have a length of 1' do
+      do_evaluate.length.should == 1
+    end
+
+    it 'should render a string representation' do
+      do_evaluate.to_s.should == '[(C-4 C#4)]'
+    end
+
+  end
+
+  describe '- When combining two complex sequences into a matrix' do
+
+    def do_evaluate
+      Clef.evaluate('[C-4 D-4 E-4] & [C-5 D-5 ___]')
+    end
+
+    it 'should combine appropriately' do
+      do_evaluate.to_s.should == '[(C-4 C-5) (D-4 D-5) (___ E-4)]'
+    end
+
+  end
+
+  describe '- When parsing complex expressions' do
+
+    it 'should parse transposed sequences' do
+      Clef.evaluate('([C-3 D-3] + 12) & [C-4]').to_s.should == '[C-4 D-4]'
+    end
+
+    it 'should parse chained unions' do
+      Clef.evaluate('[C-3] & [E-3] & [G-3]').to_s.should == '[(C-3 E-3 G-3)]'
+    end
+
+    it 'should allow transposing unions' do
+      Clef.evaluate('[C-3] & [E-3] & [G-3] + 12').to_s.should == '[(C-4 E-4 G-4)]'
+    end
+
+  end
+
+  describe '- When assigning sequences to channels' do
+
+    it 'should behave just like a sequence' do
+      Clef.evaluate('@1 = [C-3 D-3 E-3]')
+      Clef.evaluate('@1').to_s.should == '[C-3 D-3 E-3]'
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'clef'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+name: teejayvanslyke-clef
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- teejayvanslyke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-12 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: gamelan
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: midiator
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: treetop
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: andand
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: tj@elctech.com
+executables: 
+- clef
+- clef_server
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- bin/clef
+- bin/clef_server
+- lib/clef.rb
+- lib/clef.treetop
+- lib/clef/channel.rb
+- lib/clef/console.rb
+- lib/clef/environment.rb
+- lib/clef/harmony.rb
+- lib/clef/matrix.rb
+- lib/clef/note.rb
+- lib/clef/rest.rb
+- lib/clef/sequence.rb
+- lib/clef/utils.rb
+- lib/core_ext/fixnum.rb
+- spec/clef/note_spec.rb
+- spec/clef_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/teejayvanslyke/clef
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: 
+- spec/clef/note_spec.rb
+- spec/clef_spec.rb
+- spec/spec_helper.rb