zgomot 0.1.3 → 1.0.0

data/lib/zgomot/comp/markov.rb

@@ -1,40 +1,28 @@
-##############################################################################################################
 module Zgomot::Comp
 
-  #####-------------------------------------------------------------------------------------------------------
   class Markov
 
-    #####-------------------------------------------------------------------------------------------------------
     class << self
-      
-      #.........................................................................................................
       def mark
-        new 
+        new
       end
-
-    #### self
     end
-              
-    #.........................................................................................................
+
     attr_reader :current_state, :states
-    
-    #.........................................................................................................
+
     def initialize
       @current_state, @states = 0, []
     end
 
-    #.........................................................................................................
     def add(trans, &blk)
       @states << {:trans=>sum_trans(trans), :blk => blk}
     end
 
-    #.........................................................................................................
     def init(state, args={})
       @current_state = state
       states[@current_state][:blk].call(args)
     end
-    
-    #.........................................................................................................
+
     def next(args={})
       r, state = rand, states[@current_state]
       @current_state = state[:trans].select{|t| r >= t}.count
@@ -43,18 +31,12 @@ module Zgomot::Comp
       blk.arity > 0 ? blk.call(args) : blk.call
     end
 
-    #.........................................................................................................
-    # private
-    #.........................................................................................................
-    def sum_trans(trans)      
-      sums = []; trans.each_index{|i| sums[i] = trans[0..i].inject(0){|s,v| s+v}}; sums      
+    def sum_trans(trans)
+      sums = []; trans.each_index{|i| sums[i] = trans[0..i].inject(0){|s,v| s+v}}; sums
     end
-       
-    #.........................................................................................................
+
     private :sum_trans
-          
-  #### Markov
+
   end
 
-#### Zgomot::Comp 
 end

data/lib/zgomot/comp/mode.rb

@@ -1,33 +1,21 @@
-##############################################################################################################
 module Zgomot::Comp
-
-  #####-------------------------------------------------------------------------------------------------------
   class Mode
-    
-    #.........................................................................................................
     @modes = [:ionian, :dorian, :phrygian, :lydian, :mixolydian, :aeolian, :locrian]
     @intervals = [2,2,1,2,2,2,1]
     @chords = {:scale => [:maj, :min, :min, :maj, :maj, :min, :dim],
                :maj   => [:maj, nil, nil, :maj, :maj, nil, nil],
-               :min   => [nil, :min, :min, nil, nil, :min, nil],  
-               :dim   => [nil, nil, nil, nil, nil, nil, :dim],                                                                                            
+               :min   => [nil, :min, :min, nil, nil, :min, nil],
+               :dim   => [nil, nil, nil, nil, nil, nil, :dim],
                :sus2  => [:sus2, :sus2, nil, :sus2, :sus2, :sus2, nil],
                :sus4  => [:sus4, :sus4, :sus4, nil, :sus4, :sus4, nil],
                :aug   => [nil, nil, nil, nil, nil, nil, nil]}
-    
-    #####-------------------------------------------------------------------------------------------------------
+
     class << self
-    
-      #.........................................................................................................
       attr_reader :modes, :intervals, :chords
-    
-    #### self  
     end
-    
-    #####-------------------------------------------------------------------------------------------------------
+
     attr_reader :scale, :mode
-  
-    #.........................................................................................................
+
     def initialize(mode = 1)
       @mode = case mode
                  when Symbol then self.class.modes.index(mode)+1
@@ -35,32 +23,21 @@ module Zgomot::Comp
                  when nil then 1
                  else raise(Zgomot::Error, "#{mode.inspect} is invalid mode")
                end
-      raise(Zgomot::Error, "'#{mode}' is invalid mode") if @mode.nil?
-      @scale = Scale.new(self.class.intervals, @mode)        
+      @scale = Scale.new(self.class.intervals, @mode)
     end
-      
-    #.........................................................................................................
+
     def chords(chord = :scale)
       cycle_chords(Mode.chords[chord].clone)
     end
-    
-    #.........................................................................................................
+
     def method_missing(meth, *args, &blk )
       scale.send(meth, *args, &blk)
     end
 
-    #.........................................................................................................
-    # private
-    #.........................................................................................................
     def cycle_chords(cs)
-      (mode-1).times{cs.push(cs.shift)}; cs 
+      (mode-1).times{cs.push(cs.shift)}; cs
     end
 
-    #.........................................................................................................
     private :cycle_chords
-      
-  #### Mode
   end
-
-#### Zgomot::Comp 
 end

data/lib/zgomot/comp/note.rb

@@ -1,29 +1,14 @@
-##############################################################################################################
 module Zgomot::Comp
-
-  #####-------------------------------------------------------------------------------------------------------
   class Note
-
-    #####-------------------------------------------------------------------------------------------------------
-    # progession interface
-    #####-------------------------------------------------------------------------------------------------------
     class Progression
-
-      #.........................................................................................................
       def notes(prog)
         count = -1
-        prog.items.map do |d| 
+        prog.items.map do |d|
           count += 1; idx_length, idx_velocity = count % prog.length.length, count % prog.velocity.length
           pitch = d.eql?(:R) ? :R : prog.pitches[d-1]
           Zgomot::Midi::Note.new(:pitch => pitch, :length => prog.length[idx_length], :velocity => prog.velocity[idx_velocity])
         end
       end
-    
-    #### Progression  
     end
-      
-  #### Note
   end
-
-#### Zgomot::Comp 
 end

data/lib/zgomot/comp/pattern.rb

@@ -1,63 +1,40 @@
-##############################################################################################################
 module Zgomot::Comp
-
-  #####-------------------------------------------------------------------------------------------------------
   class Pattern
-
-    #####-------------------------------------------------------------------------------------------------------
     class << self
-    
-      #.......................................................................................................
       def n(p=[:C,4], opts = {})
         l = opts[:l] || 4; v = opts[:v] || 0.6
         Zgomot::Midi::Note.new(:pitch => p, :length => l, :velocity => v)
       end
 
-      #.........................................................................................................
       def c(tonic, chord = :maj, opts = {})
         l = opts[:l] || 4; v = opts[:v] || 0.6
         Chord.new(:tonic => tonic, :chord => chord, :length => l, :velocity => v)
       end
 
-      #.........................................................................................................
       def np(tonic=[:C,4], mode=0, opts = {})
         l = opts[:l] || 4; v = opts[:v] || 0.6
         Progression.new(:item => Note::Progression.new, :tonic => tonic, :mode => mode, :length => l, :velocity => v)
       end
 
-      #.........................................................................................................
       def cp(tonic=[:C,4], mode=0, opts = {})
         l = opts[:l] || 4; v = opts[:v] || 0.6
         Progression.new(:item => Chord::Progression.new(:scale), :tonic => tonic, :mode => mode, :length => l, :velocity => v)
       end
 
-      #.........................................................................................................
       def pr(percs = acoustic_bass_drum, opts = {})
         l = opts[:l] || 4; v = opts[:v] || 0.6
         Perc.new(:percs => percs, :length => l, :velocity => v)
       end
-
-    #### self
     end
-
-    #...........................................................................................................
     attr_reader :seq
-    
-    #...........................................................................................................
     def initialize(seq)
       @seq = [seq].flatten
     end
-
-    #.........................................................................................................
-    def method_missing(meth, *args, &blk )
+    def method_missing(meth, *args, &blk)
       @seq = seq.map do |p|
                p.respond_to?(meth) ? p.send(meth, *args, &blk) : p
              end
       self
     end
-
-  #### Pattern
   end
-
-#### Zgomot ::Comp
 end

data/lib/zgomot/comp/permutation.rb

@@ -1,17 +1,6 @@
-##############################################################################################################
 module Zgomot::Comp
-
-  #####-------------------------------------------------------------------------------------------------------
   class Permutation
-      
-    #.........................................................................................................
-
-    #.........................................................................................................
     def initialize
     end
-      
-  #### Markov
   end
-
-#### Zgomot::Comp 
 end

data/lib/zgomot/comp/pitch_class.rb

@@ -1,63 +1,38 @@
-##############################################################################################################
 module Zgomot::Comp
-
-  #####-------------------------------------------------------------------------------------------------------
   class PitchClass
-    
-    #.........................................................................................................
     PITCH_CLASS = {
-      :C  => 0, 
+      :C  => 0,
       :Cs => 1,
       :D  => 2,
       :Ds => 3,
       :E  => 4,
       :F  => 5,
       :Fs => 6,
-      :G  => 7, 
+      :G  => 7,
       :Gs => 8,
       :A  => 9,
       :As => 10,
-      :B  => 11 
+      :B  => 11
     }
-
-    #####-------------------------------------------------------------------------------------------------------
     class << self
-
-      #.........................................................................................................
       def next(pc, interval)
         start_pos = PITCH_CLASS[to_value(pc)]
         new(PITCH_CLASS.inject([]){|r,(c,p)|  p.eql?((start_pos+interval) % 12) ? r << c : r}.first) if start_pos
       end
-    
-      #.........................................................................................................
       def to_value(p)
         p.kind_of?(PitchClass) ? p.value : p
       end
-    
-    #### self  
     end
-    
-    #.........................................................................................................
     attr_reader :value
-  
-    #.........................................................................................................
     def initialize(p)
       raise(Zgomot::Error, "#{p} is invalid pitch class") unless PITCH_CLASS.include?(p)
       @value = p
     end
-
-    #.........................................................................................................
     def <(p)
       PITCH_CLASS[value] < PITCH_CLASS[self.class.to_value(p)]
     end
-
-    #.........................................................................................................
     def >(p)
       PITCH_CLASS[value] > PITCH_CLASS[self.class.to_value(p)]
     end
-            
-  #### PitchClass
   end
-
-#### Zgomot::Comp 
 end

data/lib/zgomot/comp/progression.rb

@@ -1,13 +1,6 @@
-##############################################################################################################
 module Zgomot::Comp
-
-  #####-------------------------------------------------------------------------------------------------------
   class Progression
-     
-    #.........................................................................................................
     attr_reader :mode, :length, :velocity, :clock, :tonic, :items, :item
-  
-    #.........................................................................................................
     def initialize(args)
       @length, @velocity, @item = [args[:length]].flatten, [args[:velocity]].flatten, args[:item]
       @items = (1..7).to_a
@@ -19,8 +12,6 @@ module Zgomot::Comp
                  else raise(Zgomot::Error, "#{args[:tonic].inspect} is invalid tonic")
                end
     end
-
-    #.........................................................................................................
     def pitches
       last_pitch, octave = tonic; pitch = [last_pitch]
       mode[0..-2].each_index{|i| pitch << PitchClass.next(tonic.first, sum(mode[0..i]))}
@@ -28,23 +19,25 @@ module Zgomot::Comp
         octave += 1 if p < last_pitch; last_pitch = p.value; [last_pitch, octave]
       end.unshift(tonic)
     end
-
-    #.........................................................................................................
     def new_respond_to?(meth, include_private=false)
-      old_respond_to?(meth) || (not notes.select{|n| n.respond_to?(meth)}.empty?)    
+      old_respond_to?(meth) or
+      notes.any?{|n| n.respond_to?(meth)} or
+      (items.respond_to?(meth) and [:reverse!, :shift, :pop, :push, :unshift].include?(meth))
     end
     alias_method :old_respond_to?, :respond_to?
     alias_method :respond_to?, :new_respond_to?
-      
-    #.........................................................................................................
     def method_missing(meth, *args, &blk)
-      if not notes.select{|n| n.respond_to?(meth)}.empty?
+      if item.respond_to?(meth)
+        item.send(meth, *args, &blk)
+      elsif notes.any?{|n| n.respond_to?(meth)}
         @notes = notes.map do |n|
                    n.respond_to?(meth) ? n.send(meth, *args, &blk) : n
                  end
-      else
+      elsif items.respond_to?(meth)
         @notes = nil
         items.send(meth, *args, &blk)
+      else
+        raise(NoMethodError, "undefined method '#{meth}' called for #{self.class}")
       end
       self
     end
@@ -55,39 +48,31 @@ module Zgomot::Comp
     def tonic!(v)
       @notes = nil; @tonic = v; self
     end
-
-    #.........................................................................................................
     def mode!(v)
       @notes = nil; @mode = v.kind_of?(Mode) ? v : Mode.new(v); self
     end
-
-    #.........................................................................................................
     def octave!(oct)
       @notes = nil; @octave = oct; self
     end
-    
-    #.........................................................................................................
     def [](*args)
       @items = args.flatten; self
     end
-    
-    #.........................................................................................................
     def velocity=(v)
       notes.each{|n| n.velocity = v}
     end
-
-    #.........................................................................................................
     def length=(v)
       notes.each{|n| n.length = v}
     end
+    def note(number)
+      notes.map{|n| n.note(number)}
+    end
 
     #.........................................................................................................
     # midi interface
+    #.........................................................................................................
     def length_to_sec
       notes.inject(0.0){|s,n| s += n.length_to_sec}
     end
-
-    #.........................................................................................................
     def time=(time)
       @clock = Zgomot::Midi::Clock.new
       clock.update(time)
@@ -96,42 +81,23 @@ module Zgomot::Comp
         clock.update(n.length_to_sec)
       end
     end
-    
-    #.........................................................................................................
     def channel=(c)
       notes.each{|n| n.channel = c}
     end
-    
-    #.........................................................................................................
     def to_midi
       notes.map{|n| n.to_midi}
     end
-
-    #.........................................................................................................
     def offset_time=(t)
       notes.each{|n| n.offset_time = t}
     end
-    
-    #.........................................................................................................
-    def to_ary
-      notes
-    end
-
-    #.........................................................................................................
     def notes
       @notes ||= item.notes(self)
     end
-  
-    #.........................................................................................................
+
     def sum(a)
       a.inject(0) {|s,n| s+n}
     end
-  
-    #.........................................................................................................
+
     private :sum
-  
-  #### Progression
   end
-
-#### Zgomot::Comp 
 end

data/lib/zgomot/comp/scale.rb

@@ -1,13 +1,9 @@
-##############################################################################################################
 module Zgomot::Comp
 
-  #####-------------------------------------------------------------------------------------------------------
   class Scale
-    
-    #####-------------------------------------------------------------------------------------------------------
+
     attr_reader :intervals, :shift, :scale
-  
-    #.........................................................................................................
+
     def initialize(int, shift)
       @intervals = int
       @shift = shift - 1
@@ -15,18 +11,13 @@ module Zgomot::Comp
       self.shift.times{self.next}
     end
 
-    #.........................................................................................................
     def next
-      scale.push(scale.shift) 
+      scale.push(scale.shift)
     end
-    
-    #.........................................................................................................
+
     def method_missing(method, *args, &blk )
       scale.send(method, *args, &blk)
     end
-      
-  #### Scale
-  end
 
-#### Zgomot::Comp 
+  end
 end

data/lib/zgomot/config.rb

@@ -1,51 +1,36 @@
-##############################################################################################################
 module Zgomot
 
-  #####-------------------------------------------------------------------------------------------------------
   class Error < Exception; end
 
-  #.........................................................................................................
   VERSION = "0.0.0"
   PLAY_DELAY = 1.0
   DISPATCHER_POLL = 1.133
 
-  #.........................................................................................................
   DEFAULT_CONFIG = {
     :beats_per_minute => 120,
     :time_signature   => '4/4',
     :resolution       => '1/32'
   }
 
-  #.........................................................................................................
   @config_file = "zgomot.yml"
   @app_path = File.dirname($0)
   @log_file = STDOUT
   @live = false
-  
-  ####......................................................................................................
-  class << self
 
-    #.......................................................................................................
+  class << self
     attr_accessor :config_file, :app_path, :log_file, :config, :live
-
-    #.......................................................................................................
     def logger; @logger ||= Logger.new(STDOUT); end
     def logger=(logger); @logger = logger; end
-
-    #.......................................................................................................
     def add_path(dir)
       File.join(Zgomot.app_path, dir)
     end
-
-  #### self
   end
 
-  #.......................................................................................................
   @config_file = add_path(config_file)
   user_config = if File.exist?(config_file)
                   (c = File.open(config_file) {|yf| YAML::load(yf)}) ? c : {}
                 else; {}; end
-  @config = DEFAULT_CONFIG.inject({}){|r,(k,v)| r.update(k => (user_config[k.to_s] || v))}         
-                          
+  @config = DEFAULT_CONFIG.inject({}){|r,(k,v)| r.update(k => (user_config[k.to_s] || v))}
+
 end