better pattern class methods

lib/diamond/pattern.rb

@@ -3,6 +3,50 @@ module Diamond
   # Pattern that the sequence is derived from given the parameters and input
   class Pattern
 
+    module ClassMethods
+
+      # All patterns
+      # @return [Array<Pattern>]
+      def all
+        @patterns ||= []
+      end
+
+      # Find a pattern by its name (case insensitive)
+      # @param [String, Symbol] name
+      # @return [Pattern]
+      def find(name)
+        all.find { |pattern| pattern.name.to_s.downcase == name.to_s.downcase }
+      end
+
+      # Construct and add a pattern
+      # @param [Symbol, String] name
+      # @param [Proc] block
+      # @return [Array<Pattern>]
+      def add(*args, &block)
+        all << new(*args, &block)
+      end
+
+      # Add a pattern
+      # @param [Pattern] pattern
+      # @return [Array<Pattern>]
+      def <<(pattern)
+        all << pattern
+      end
+
+      # @return [Pattern]
+      def first
+        all.first
+      end
+
+      # @return [Pattern]
+      def last
+        all.last
+      end
+
+    end
+
+    extend ClassMethods
+
     attr_reader :name
 
     # @param [String, Symbol] name A name to identify the pattern by eg "up/down"
@@ -21,44 +65,24 @@ def compute(range, interval)
       @proc.call(range, interval)
     end
 
-    # All patterns
-    # @return [Array<Pattern>]
-    def self.all
-      @patterns
-    end
-
-    # Find a pattern by its name (case insensitive)
-    # @param [String, Symbol] name
-    # @return [Pattern]
-    def self.find(name)
-      all.find { |pattern| pattern.name.to_s.downcase == name.to_s.downcase }
-    end
-
-    @patterns = []
-    class << self 
-      alias_method :[], :find
-
-      attr_reader :patterns
-    end
-
     # Standard preset patterns
     module Presets
 
-      Pattern.patterns << Pattern.new("Up") do |range, interval|
+      Pattern << Pattern.new("Up") do |range, interval|
         0.upto(range).map { |num| num * interval }
       end
 
-      Pattern.patterns << Pattern.new("Down") do |range, interval|
+      Pattern << Pattern.new("Down") do |range, interval|
         range.downto(0).map { |num| num * interval }
       end
 
-      Pattern.patterns << Pattern.new("UpDown") do |range, interval|
+      Pattern << Pattern.new("UpDown") do |range, interval|
         up = 0.upto(range).map { |num| num * interval }
         down = [(range - 1), 0].max.downto(0).map { |num| num * interval }
         up + down
       end
 
-      Pattern.patterns << Pattern.new("DownUp") do |range, interval|
+      Pattern << Pattern.new("DownUp") do |range, interval|
         down = range.downto(0).map { |num| num * interval }
         up = 1.upto(range).map { |num| num * interval }
         down + up

lib/diamond/sequence_parameters.rb

@@ -127,7 +127,7 @@ def apply_options(options)
       @interval = constrain((options[:interval] || 12), :range => RANGE[:interval])
       @range = constrain((options[:range] || 3), :range => RANGE[:range])
       @pattern_offset = constrain((options[:pattern_offset] || 0),:range => RANGE[:pattern_offset])
-      @pattern = options[:pattern] || Pattern.all.first
+      @pattern = options[:pattern] || Pattern.first
       @rate = constrain((options[:rate] || 8), :range => 0..@resolution)
       @gate = constrain((options[:gate] || 75), :range => RANGE[:gate])
       self