mtk 0.0.2 → 0.0.3

data/lib/mtk/helper/event_builder.rb

@@ -1,85 +0,0 @@
-module MTK
-  module Helper
-
-    # A helper class for {Sequencer}s.
-    # Takes a list of patterns and constructs a list of {Event}s from the next elements in each pattern.
-    class EventBuilder
-
-      DEFAULT_PITCH = MTK::Pitches::C4
-      DEFAULT_INTENSITY = MTK::Intensities::f
-      DEFAULT_DURATION = 1
-
-      def initialize(patterns, options={})
-        @patterns = patterns
-        @options = options
-        @max_interval = options.fetch :max_interval, 12
-        rewind
-      end
-
-      # Build a list of events from the next element in each {Pattern}
-      # @return [Array] an array of events
-      def next
-        pitches = []
-        intensity = @default_intensity
-        duration = @default_duration
-
-        for pattern in @patterns
-          element = pattern.next
-          case element
-            when Pitch         then pitches << element
-            when PitchSet      then pitches += element.pitches
-            when PitchClass    then pitches += pitches_for_pitch_classes([element], @previous_pitch || @default_pitch)
-            when PitchClassSet then pitches += pitches_for_pitch_classes(element, @previous_pitch || @default_pitch)
-            else case pattern.type
-              when :pitch
-                if element.is_a? Numeric
-                  # pitch interval case
-                  if @previous_pitches
-                    pitches += @previous_pitches.map{|pitch| pitch + element }
-                  else
-                    pitches << ((@previous_pitch || @default_pitch) + element)
-                  end
-                end
-              when :intensity then intensity = element
-              when :duration then duration = element
-            end
-          end
-        end
-
-        if not pitches.empty?
-          @previous_pitch = pitches.last
-          @previous_pitches = pitches.length > 1 ? pitches : nil
-          pitches.map{|pitch| Note(pitch,intensity,duration) }
-        else
-          nil
-        end
-      end
-
-      # Reset the EventBuilder to its initial state
-      def rewind
-        @default_pitch = @options.fetch :default_pitch, DEFAULT_PITCH
-        @default_intensity = @options.fetch :default_intensity, DEFAULT_INTENSITY
-        @default_duration = @options.fetch :default_duration, DEFAULT_DURATION
-        @previous_pitch = nil
-        @previous_pitches = nil
-        @patterns.each{|pattern| pattern.rewind }
-      end
-
-      ########################
-      private
-
-      def pitches_for_pitch_classes(pitch_classes, previous_pitch)
-        pitches = []
-        for pitch_class in pitch_classes
-          pitch = previous_pitch.nearest(pitch_class)
-          pitch -= 12 if pitch > @default_pitch+@max_interval # keep within max_distance of start (default is one octave)
-          pitch += 12 if pitch < @default_pitch-@max_interval
-          pitches << pitch
-        end
-        pitches
-      end
-
-    end
-
-  end
-end

data/lib/mtk/helper/pseudo_constants.rb

@@ -1,26 +0,0 @@
-module MTK::Helper
-
-
-  # Extension for modules that want to define pseudo-constants (constant-like values with lower-case names)
-  module PseudoConstants
-
-    # Define a module method and module function (available both through the module namespace and as a mixin method),
-    # to provide a constant with a lower-case name.
-    #
-    # @param name [Symbol] the name of the pseudo-constant
-    # @param value [Object] the value of the pseudo-constant
-    # @return [nil]
-    def define_constant name, value
-      if name[0..0] =~ /[A-Z]/
-        const_set name, value # it's just a normal constant
-      else
-        # the pseudo-constant definition is the combination of a method and module_function:
-        define_method(name) { value }
-        module_function name
-      end
-      nil
-    end
-
-  end
-
-end

data/lib/mtk/lang/grammar.rb

@@ -1,17 +0,0 @@
-require 'citrus'
-Citrus.load File.join(File.dirname(__FILE__),'mtk_grammar')
-
-module MTK
-  module Lang
-
-    # Parser for the {file:lib/mtk/lang/mtk_grammar.citrus MTK grammar}
-    class Grammar
-
-      def self.parse(syntax, root=:pitch)
-        MTK_Grammar.parse(syntax, :root => root).value
-      end
-
-    end
-
-  end
-end

data/lib/mtk/note.rb

@@ -1,63 +0,0 @@
-module MTK
-
-  # A musical {Event} defined by a {Pitch}, intensity, and duration
-  class Note < Event
-
-    # frequency of the note as a Pitch
-    attr_reader :pitch
-
-    def initialize(pitch, intensity, duration)
-      @pitch = pitch
-      super(intensity, duration)
-    end
-
-    def self.from_hash(hash)
-      new hash[:pitch], hash[:intensity], hash[:duration]
-    end
-
-    def to_hash
-      super.merge({ :pitch => @pitch })
-    end
-
-    def self.from_midi(pitch, velocity, beats)
-      new Pitches::PITCHES[pitch], velocity/127.0, beats
-    end
-
-    def to_midi
-      [pitch.to_i, velocity, duration]
-    end
-
-    def transpose(interval)
-      self.class.new(@pitch+interval, @intensity, @duration)
-    end
-
-    def invert(around_pitch)
-      self.class.new(@pitch.invert(around_pitch), @intensity, @duration)
-    end
-
-    def == other
-      super and other.respond_to? :pitch and @pitch == other.pitch
-    end
-
-    def to_s
-      "Note(#{pitch}, #{super})"
-    end
-
-    def inspect
-      "Note(#{pitch}, #{super})"
-    end
-
-  end
-
-  # Construct a {Note} from any supported type
-  def Note(*anything)
-    anything = anything.first if anything.size == 1
-    case anything
-      when Array then Note.new(*anything)
-      when Note then anything
-      else raise "Note doesn't understand #{anything.class}"
-    end
-  end
-  module_function :Note
-
-end

data/lib/mtk/pattern/abstract_pattern.rb

@@ -1,132 +0,0 @@
-module MTK
-  module Pattern
-
-    # A pattern of elements that can be emitted one element at a time via calls to {#next}.
-    #
-    # Patterns can be reset to the beginning via {#rewind}.
-    #
-    # @abstract Subclass and override {#advance!} and {#current} to implement a Pattern
-    #
-    class AbstractPattern
-      include Helper::Collection
-      include Enumerator
-
-      # The elements in the pattern
-      attr_reader :elements
-
-      attr_reader :options
-
-      # The type of elements in the pattern, such as :pitch, :intensity, or :duration
-      #
-      # This is often needed by {Sequencer} classes to interpret the pattern elements.
-      attr_reader :type
-
-      # The number of elements emitted since the last {#rewind}
-      attr_reader :element_count
-      
-      # The maximum number of elements this Pattern will emit before a StopIteration exception
-      attr_reader :max_elements
-
-      # @param elements [Enumerable, #to_a] the list of elements in the pattern
-      # @param options [Hash] the pattern options
-      # @option options [String] :type the pattern {#type}
-      # @option options [Fixnum] :max_elements the {#max_elements}
-      def initialize(elements, options={})
-        elements = elements.to_a if elements.respond_to? :to_a and not elements.is_a? Proc # Proc check prevents warnings in Ruby 1.8
-        @elements = elements
-        @options = options
-        @type = options[:type]
-        @max_elements = options[:max_elements]
-        rewind
-      end
-
-      # Construct a pattern from an Array.
-      # @param (see #initialize)
-      # @option (see #initialize)
-      # @see #initialize
-      def self.from_a(elements, options={})
-        new(elements, options)
-      end
-
-      # Reset the pattern to the beginning
-      def rewind
-        @current = nil
-        @element_count = 0
-        self
-      end
-
-      # Emit the next element in the pattern
-      # @raise StopIteration when the pattern has emitted all values, or has hit the {#max_elements} limit.
-      def next
-        if @current.is_a? Enumerator
-          begin
-            subpattern_next = @current.next
-            subpattern_has_next = true
-          rescue StopIteration
-            subpattern_has_next = false
-          end
-
-          return emit subpattern_next if subpattern_has_next
-          # else fall through and continue with normal behavior
-        end
-
-        begin
-          advance!
-        rescue StopIteration
-          @current = nil
-          raise
-        end
-
-        @current = current
-        if @current.is_a? Enumerator
-          @current.rewind # start over, in case we already enumerated this element and then did a rewind
-          return self.next
-        end
-
-        emit @current
-      end
-
-
-      ##################
-      protected
-
-      # Update internal state (index, etc) so that {#current} will refer to the next element.
-      # @note Override this method in a subclass to define a custom Pattern.
-      # @raise StopIteration if there are no more elements
-      def advance!
-        raise StopIteration if @elements.nil? or @elements.empty?
-      end
-
-      # The current element in the pattern, which will be returned by {#next} (after a call to {#advance!}).
-      # @note Override this method in a subclass to define a custom Pattern.
-      def current
-        @elements[0]
-      end
-
-
-      ##################
-      private
-
-      def emit element
-        @element_count += 1
-        raise StopIteration if @max_elements and @element_count > @max_elements
-        element
-      end
-    end
-
-    # Build any "TypedPattern" (like PitchCycle or DurationPalindrome) or even just Pattern
-    def method_missing(method, *args, &block)
-      # Assuming we get something like PitchCycle, split into 'Pitch' and 'Cycle'
-      camel_case_words = method.to_s.gsub(/([a-z])([A-Z])/,'\1 \2').split(' ')
-      pattern = MTK::Pattern.const_get camel_case_words.last
-      if camel_case_words.length > 1
-        type = camel_case_words.first.downcase.to_sym
-        pattern.new(args, :type => type)
-      else
-        pattern.new(args)
-      end
-    end
-    module_function :method_missing
-
-  end
-end

data/lib/mtk/pattern/cycle.rb

@@ -1,51 +0,0 @@
-module MTK
-  module Pattern
-
-    # An endless enumerator that outputs an element one at a time from a list of elements,
-    # looping back to the beginning when elements run out.
-    class Cycle < AbstractPattern
-
-      # The number of cycles emitted (1 cycle == all elements emitted) since the last {#rewind}
-      attr_reader :cycle_count
-      
-      # The maximum number of cycles this Pattern will emit before a StopIteration exception
-      attr_reader :max_cycles
-
-      def initialize(elements, options={})
-        super
-        @max_cycles = options[:max_cycles]
-      end
-
-      # Reset the sequence to the beginning
-      def rewind
-        @index = -1
-        @cycle_count = 0
-        super
-      end
-
-      ###################
-      protected
-
-      # (see AbstractPattern#advance!)
-      def advance!
-        super # base advance!() implementation prevents infinite loops with empty patterns
-        @index += 1
-        if @index >= @elements.length
-          @cycle_count += 1
-          if @max_cycles and @cycle_count >= @max_cycles
-            raise StopIteration
-          end
-          @index = -1
-          advance!
-        end
-      end
-
-      # (see AbstractPattern#current)
-      def current
-        @elements[@index]
-      end
-
-    end
-
-  end
-end

data/lib/mtk/pattern/enumerator.rb

@@ -1,26 +0,0 @@
-module MTK
-  module Pattern
-
-    # The core interface for all Patterns.
-    #
-    # This module doesn't provide any useful default functionality.
-    # It only indicates that a class is compatible with MTK's pattern enumerator interface.
-    #
-    module Enumerator
-
-      # Return the next element in the enumerator
-      # @raise StopIteration when no more elements are available
-      def next
-        raise StopIteration
-      end
-
-      # Reset the enumerator to the beginning
-      # @return self
-      def rewind
-        self
-      end
-
-    end
-
-  end
-end

data/lib/mtk/pattern/function.rb

@@ -1,46 +0,0 @@
-module MTK
-  module Pattern
-
-    # An arbitrary function that dynamically generates elements.
-    #
-    class Function < AbstractPattern
-
-      attr_reader :function
-      
-      def initialize(elements, options={})
-        super
-        @function = @elements
-        # unpack from the varargs Array that may be passed in from the "convenience constructor methods" defined in MTK::Pattern                        \
-        @function = @function.first if @function.is_a? Enumerable
-      end
-      
-      # Reset the sequence to the beginning
-      def rewind
-        @prev = nil
-        @function_call_count = -1
-        super
-      end
-
-      ###################
-      protected
-
-      # (see AbstractPattern#advance!)
-      def advance!
-        raise StopIteration if @elements.nil?
-      end
-
-      # (see AbstractPattern#current)
-      def current
-        @function_call_count += 1
-        @prev = case @function.arity
-          when 0 then @function.call
-          when 1 then @function.call(@prev)
-          when 2 then @function.call(@prev, @function_call_count)
-          else @function.call(@prev, @function_call_count, @element_count)
-        end
-      end
-
-    end
-
-  end
-end