cyclotone 0.1.0 → 1.0.0

data/lib/cyclotone/mini_notation/ast.rb

@@ -4,6 +4,19 @@ module Cyclotone
   module MiniNotation
     module AST
       class Node
+        def self.deep_freeze(value)
+          case value
+          when Array
+            value.map { |entry| deep_freeze(entry) }.freeze
+          when Hash
+            value.each_with_object({}) do |(key, entry), frozen_hash|
+              frozen_hash[deep_freeze(key)] = deep_freeze(entry)
+            end.freeze
+          else
+            value.freeze
+          end
+        end
+
         def ==(other)
           other.is_a?(self.class) && to_h == other.to_h
         end
@@ -13,12 +26,17 @@ module Cyclotone
         def hash
           [self.class, to_h].hash
         end
+
+        def to_mn
+          AST.to_source(self)
+        end
       end
 
       class Atom < Node
         attr_reader :value, :sample
 
         def initialize(value:, sample: nil)
+          super()
           @value = value
           @sample = sample
           freeze
@@ -43,7 +61,8 @@ module Cyclotone
         attr_reader :elements
 
         def initialize(elements:)
-          @elements = elements.freeze
+          super()
+          @elements = Node.deep_freeze(elements)
           freeze
         end
 
@@ -56,7 +75,8 @@ module Cyclotone
         attr_reader :patterns
 
         def initialize(patterns:)
-          @patterns = patterns.freeze
+          super()
+          @patterns = Node.deep_freeze(patterns)
           freeze
         end
 
@@ -69,7 +89,8 @@ module Cyclotone
         attr_reader :patterns
 
         def initialize(patterns:)
-          @patterns = patterns.freeze
+          super()
+          @patterns = Node.deep_freeze(patterns)
           freeze
         end
 
@@ -82,6 +103,7 @@ module Cyclotone
         attr_reader :pattern, :count
 
         def initialize(pattern:, count:)
+          super()
           @pattern = pattern
           @count = count.to_i
           freeze
@@ -96,6 +118,7 @@ module Cyclotone
         attr_reader :pattern, :count
 
         def initialize(pattern:, count:)
+          super()
           @pattern = pattern
           @count = count.to_i
           freeze
@@ -110,6 +133,7 @@ module Cyclotone
         attr_reader :pattern, :amount
 
         def initialize(pattern:, amount:)
+          super()
           @pattern = pattern
           @amount = amount
           freeze
@@ -124,6 +148,7 @@ module Cyclotone
         attr_reader :pattern, :amount
 
         def initialize(pattern:, amount:)
+          super()
           @pattern = pattern
           @amount = amount
           freeze
@@ -142,6 +167,7 @@ module Cyclotone
         attr_reader :pattern, :probability
 
         def initialize(pattern:, probability:)
+          super()
           @pattern = pattern
           @probability = probability
           freeze
@@ -156,7 +182,8 @@ module Cyclotone
         attr_reader :patterns
 
         def initialize(patterns:)
-          @patterns = patterns.freeze
+          super()
+          @patterns = Node.deep_freeze(patterns)
           freeze
         end
 
@@ -169,6 +196,7 @@ module Cyclotone
         attr_reader :pattern, :pulses, :steps, :rotation
 
         def initialize(pattern:, pulses:, steps:, rotation: 0)
+          super()
           @pattern = pattern
           @pulses = pulses.to_i
           @steps = steps.to_i
@@ -185,7 +213,8 @@ module Cyclotone
         attr_reader :patterns, :steps
 
         def initialize(patterns:, steps: nil)
-          @patterns = patterns.freeze
+          super()
+          @patterns = Node.deep_freeze(patterns)
           @steps = steps&.to_i
           freeze
         end
@@ -194,6 +223,57 @@ module Cyclotone
           { patterns: patterns, steps: steps }
         end
       end
+
+      module_function
+
+      def to_source(node)
+        case node
+        when Atom
+          node.sample ? "#{format_atom(node.value)}:#{node.sample}" : format_atom(node.value)
+        when Rest
+          "~"
+        when Sequence
+          node.elements.map { |element| to_source(element) }.join(" ")
+        when Stack
+          "[#{node.patterns.map { |pattern| to_source(pattern) }.join(", ")}]"
+        when Alternating
+          "<#{node.patterns.map { |pattern| to_source(pattern) }.join(" ")}>"
+        when Repeat
+          "#{group_if_needed(node.pattern)}*#{node.count}"
+        when Replicate
+          "#{group_if_needed(node.pattern)}!#{node.count}"
+        when Slow
+          "#{group_if_needed(node.pattern)}/#{node.amount}"
+        when Elongate
+          "#{group_if_needed(node.pattern)}@#{node.amount}"
+        when Degrade
+          "#{group_if_needed(node.pattern)}?#{node.probability}"
+        when Choice
+          node.patterns.map { |pattern| to_source(pattern) }.join(" | ")
+        when Euclidean
+          "#{group_if_needed(node.pattern)}(#{node.pulses},#{node.steps},#{node.rotation})"
+        when Polymetric
+          suffix = node.steps ? "%#{node.steps}" : ""
+          "{#{node.patterns.map { |pattern| to_source(pattern) }.join(", ")}}#{suffix}"
+        else
+          raise ArgumentError, "unsupported AST node #{node.class}"
+        end
+      end
+
+      def group_if_needed(node)
+        node.is_a?(Atom) || node.is_a?(Rest) ? to_source(node) : "[#{to_source(node)}]"
+      end
+      private_class_method :group_if_needed
+
+      def format_atom(value)
+        return "#{value.numerator}/#{value.denominator}" if value.is_a?(Rational)
+
+        text = value.to_s
+        return text if text.match?(/\A[\w.-]+\z/)
+
+        "\"#{text.gsub("\\", "\\\\\\").gsub("\"", "\\\"")}\""
+      end
+      private_class_method :format_atom
     end
   end
 end

data/lib/cyclotone/mini_notation/compiler.rb

@@ -3,6 +3,8 @@
 module Cyclotone
   module MiniNotation
     class Compiler
+      MAX_EXPANSION = 4096
+
       def compile(node)
         case node
         when AST::Atom
@@ -16,12 +18,12 @@ module Cyclotone
         when AST::Alternating
           compile_alternating(node)
         when AST::Repeat
+          validate_expansion_count(node.count, "repeat count")
           compile(node.pattern).fast(node.count)
         when AST::Replicate
+          validate_expansion_count(node.count, "replicate count")
           Pattern.timecat(Array.new(node.count) { [1, compile(node.pattern)] })
-        when AST::Slow
-          compile(node.pattern).slow(node.amount)
-        when AST::Elongate
+        when AST::Slow, AST::Elongate
           compile(node.pattern).slow(node.amount)
         when AST::Degrade
           compile(node.pattern).degrade_by(node.probability)
@@ -60,6 +62,7 @@ module Cyclotone
 
       def compile_alternating(node)
         patterns = node.patterns.map { |pattern| compile(pattern) }
+        raise ArgumentError, "alternating requires patterns" if patterns.empty?
 
         Pattern.new do |span|
           cycle = span.cycle_number
@@ -77,21 +80,21 @@ module Cyclotone
       end
 
       def compile_polymetric(node)
-        base_steps = (node.steps || step_count(node.patterns.first)).to_i
-        base_steps = 1 if base_steps <= 0
+        raise ArgumentError, "polymetric requires patterns" if node.patterns.empty?
+
+        base_steps = Pattern.to_rational(node.steps || step_count(node.patterns.first))
+        raise ArgumentError, "polymetric steps must be positive" unless base_steps.positive?
 
         Pattern.stack(
           node.patterns.map do |pattern|
-            pattern_steps = [step_count(pattern), 1].max
-            compile(pattern).slow(Rational(pattern_steps, base_steps))
+            pattern_steps = [Pattern.to_rational(step_count(pattern)), Rational(1)].max
+            compile(pattern).slow(pattern_steps / base_steps)
           end
         )
       end
 
       def step_count(node)
         case node
-        when AST::Atom, AST::Rest
-          1
         when AST::Sequence
           node.elements.sum { |element| step_count(element) }
         when AST::Stack, AST::Alternating, AST::Choice
@@ -101,7 +104,7 @@ module Cyclotone
         when AST::Slow, AST::Degrade
           step_count(node.pattern)
         when AST::Elongate
-          step_count(node.pattern) * node.amount.to_i
+          Pattern.to_rational(step_count(node.pattern)) * Pattern.to_rational(node.amount)
         when AST::Euclidean
           [node.steps, 1].max * step_count(node.pattern)
         when AST::Polymetric
@@ -110,6 +113,11 @@ module Cyclotone
           1
         end
       end
+
+      def validate_expansion_count(count, label)
+        raise ArgumentError, "#{label} must be positive" unless count.positive?
+        raise ArgumentError, "#{label} must be <= #{MAX_EXPANSION}" if count > MAX_EXPANSION
+      end
     end
   end
 end

data/lib/cyclotone/mini_notation/parser.rb

@@ -27,11 +27,12 @@ module Cyclotone
       }.freeze
 
       def parse(input)
-        @tokens = tokenize(input.to_s)
+        @source = input.to_s
+        @tokens = tokenize(@source)
         @index = 0
 
         skip_spaces
-        raise ParseError.new("input is empty", line: 1, column: 1) if current.type == :eof
+        raise ParseError.new("input is empty", line: 1, column: 1, source: @source) if current.type == :eof
 
         ast = parse_stack(terminators: [:eof])
         skip_spaces
@@ -86,6 +87,12 @@ module Cyclotone
             next
           end
 
+          if char.match?(/[0-9]/) || (char == "-" && input[index + 1]&.match?(/[0-9]/))
+            token, index, column = tokenize_number(input, index, line, column)
+            tokens << token
+            next
+          end
+
           if SINGLE_CHAR_TOKENS.key?(char)
             tokens << Token.new(type: SINGLE_CHAR_TOKENS[char], value: char, line: line, column: column)
             index += 1
@@ -93,15 +100,9 @@ module Cyclotone
             next
           end
 
-          if char.match?(/[0-9]/)
-            start_index = index
-            start_column = column
-            while index < input.length && input[index].match?(/[0-9.]/)
-              index += 1
-              column += 1
-            end
-
-            tokens << Token.new(type: :number, value: input[start_index...index], line: line, column: start_column)
+          if %w[" '].include?(char)
+            token, index, column = tokenize_quoted(input, index, line, column)
+            tokens << token
             next
           end
 
@@ -130,6 +131,8 @@ module Cyclotone
 
         while accept(:comma)
           skip_spaces
+          raise parse_error("empty stack branch") if terminators.include?(current.type) || current.type == :comma
+
           patterns << parse_choice(terminators: terminators + [:comma])
           skip_spaces
         end
@@ -145,6 +148,8 @@ module Cyclotone
 
         while accept(:pipe)
           skip_spaces
+          raise parse_error("empty choice branch") if terminators.include?(current.type) || current.type == :pipe
+
           patterns << parse_sequence(terminators: terminators + [:pipe])
           skip_spaces
         end
@@ -199,26 +204,30 @@ module Cyclotone
           node = case current.type
                  when :star
                    advance
-                   AST::Repeat.new(pattern: node, count: parse_integer)
+                   AST::Repeat.new(pattern: node, count: parse_positive_integer("repeat count"))
                  when :bang
                    advance
-                   AST::Replicate.new(pattern: node, count: parse_integer)
+                   AST::Replicate.new(pattern: node, count: parse_positive_integer("replicate count"))
                  when :slash
                    advance
-                   AST::Slow.new(pattern: node, amount: parse_number)
+                   AST::Slow.new(pattern: node, amount: parse_positive_number("slow amount"))
                  when :at
                    advance
-                   AST::Elongate.new(pattern: node, amount: parse_number)
+                   AST::Elongate.new(pattern: node, amount: parse_positive_number("elongate amount"))
                  when :question
                    advance
-                   probability = current.type == :number ? parse_number : 0.5
+                   probability = if current.type == :number
+                                   parse_probability
+                                 elsif implicit_probability_token?(current.type)
+                                   0.5
+                                 else
+                                   raise parse_error("probability must be between 0 and 1")
+                                 end
                    AST::Degrade.new(pattern: node, probability: probability)
                  when :colon
                    advance
-                   sample = parse_integer
-                   unless node.is_a?(AST::Atom)
-                     raise parse_error("sample suffix can only be applied to atoms")
-                   end
+                   sample = parse_non_negative_integer("sample number")
+                   raise parse_error("sample suffix can only be applied to atoms") unless node.is_a?(AST::Atom)
 
                    node.with_sample(sample)
                  when :lparen
@@ -240,8 +249,7 @@ module Cyclotone
           AST::Atom.new(value: token.value)
         when :number
           advance
-          numeric_value = token.value.include?(".") ? token.value.to_f : token.value.to_i
-          AST::Atom.new(value: numeric_value)
+          AST::Atom.new(value: number_value(token.value))
         when :tilde
           advance
           AST::Rest.new
@@ -264,14 +272,12 @@ module Cyclotone
 
       def parse_euclidean(node)
         expect(:lparen)
-        pulses = parse_integer
+        pulses = parse_non_negative_integer("euclidean pulses")
         expect(:comma)
-        steps = parse_integer
+        steps = parse_positive_integer("euclidean steps")
         rotation = 0
 
-        if accept(:comma)
-          rotation = parse_integer
-        end
+        rotation = parse_integer("euclidean rotation") if accept(:comma)
 
         expect(:rparen)
         AST::Euclidean.new(pattern: node, pulses: pulses, steps: steps, rotation: rotation)
@@ -279,14 +285,18 @@ module Cyclotone
 
       def parse_polymetric
         expect(:lbrace)
-        patterns = [parse_sequence(terminators: [:comma, :rbrace])]
+        raise parse_error("empty polymetric branch") if current.type == :rbrace
+
+        patterns = [parse_sequence(terminators: %i[comma rbrace])]
 
         while accept(:comma)
-          patterns << parse_sequence(terminators: [:comma, :rbrace])
+          raise parse_error("empty polymetric branch") if %i[comma rbrace].include?(current.type)
+
+          patterns << parse_sequence(terminators: %i[comma rbrace])
         end
 
         expect(:rbrace)
-        steps = accept(:percent) ? parse_integer : nil
+        steps = accept(:percent) ? parse_positive_integer("polymetric steps") : nil
 
         AST::Polymetric.new(patterns: patterns, steps: steps)
       end
@@ -294,11 +304,42 @@ module Cyclotone
       def parse_number
         token = expect(:number)
 
-        token.value.include?(".") ? token.value.to_f : token.value.to_i
+        number_value(token.value)
       end
 
-      def parse_integer
-        expect(:number).value.to_i
+      def parse_integer(label = "integer")
+        token = expect(:number)
+        raise parse_error("#{label} must be an integer") if token.value.include?(".") || token.value.include?("/")
+
+        token.value.to_i
+      end
+
+      def parse_positive_number(label)
+        value = parse_number
+        raise parse_error("#{label} must be positive") unless value.positive?
+
+        value
+      end
+
+      def parse_probability
+        value = parse_number
+        raise parse_error("probability must be between 0 and 1") unless value.between?(0, 1)
+
+        value
+      end
+
+      def parse_positive_integer(label)
+        value = parse_integer(label)
+        raise parse_error("#{label} must be positive") unless value.positive?
+
+        value
+      end
+
+      def parse_non_negative_integer(label)
+        value = parse_integer(label)
+        raise parse_error("#{label} must be non-negative") if value.negative?
+
+        value
       end
 
       def build_group(elements)
@@ -343,7 +384,100 @@ module Cyclotone
       end
 
       def parse_error(message)
-        ParseError.new(message, line: current.line, column: current.column)
+        ParseError.new(message, line: current.line, column: current.column, source: @source)
+      end
+
+      def implicit_probability_token?(type)
+        %i[
+          space eof rbracket rangle rbrace comma pipe dot star bang slash at question colon lparen
+        ].include?(type)
+      end
+
+      def tokenize_number(input, index, line, column)
+        start_index = index
+        start_column = column
+
+        if input[index] == "-"
+          index += 1
+          column += 1
+        end
+
+        while index < input.length && input[index].match?(/[0-9]/)
+          index += 1
+          column += 1
+        end
+
+        if input[index] == "."
+          unless input[index + 1]&.match?(/[0-9]/)
+            raise ParseError.new("invalid number literal", line: line, column: column, source: @source)
+          end
+
+          index += 1
+          column += 1
+
+          while index < input.length && input[index].match?(/[0-9]/)
+            index += 1
+            column += 1
+          end
+        end
+
+        raise ParseError.new("invalid number literal", line: line, column: column, source: @source) if input[index] == "."
+
+        if input[index] == "/" && input[index + 1]&.match?(/[0-9]/)
+          index += 1
+          column += 1
+          denominator_start = index
+
+          while index < input.length && input[index].match?(/[0-9]/)
+            index += 1
+            column += 1
+          end
+
+          if input[denominator_start...index].to_i.zero?
+            raise ParseError.new("rational denominator must be positive", line: line, column: denominator_start + 1, source: @source)
+          end
+        end
+
+        [Token.new(type: :number, value: input[start_index...index], line: line, column: start_column), index, column]
+      end
+
+      def number_value(value)
+        return Rational(value) if value.include?("/")
+        return value.to_f if value.include?(".")
+
+        value.to_i
+      end
+
+      def tokenize_quoted(input, index, line, column)
+        quote = input[index]
+        start_column = column
+        index += 1
+        column += 1
+        value = +""
+
+        while index < input.length
+          char = input[index]
+
+          if char == quote
+            index += 1
+            column += 1
+            return [Token.new(type: :word, value: value, line: line, column: start_column), index, column]
+          end
+
+          if char == "\\"
+            index += 1
+            column += 1
+            raise ParseError.new("unterminated escape sequence", line: line, column: column, source: @source) if index >= input.length
+
+            char = input[index]
+          end
+
+          value << char
+          index += 1
+          column += 1
+        end
+
+        raise ParseError.new("unterminated quoted atom", line: line, column: start_column, source: @source)
       end
     end
   end