frausto 0.2.0 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6175ca1a7aaec33d9d762997e3016e76be2892da7ca7b65585d7cdd8c05b6423
-  data.tar.gz: b0e41102e41bbb150a7d6ad48b841054577715b1ca1d2507b73b6ff2793c549f
+  metadata.gz: e6f5347160a2abe4136e948b171065dbab0d4b2816d57dc3d341a7b039c3717b
+  data.tar.gz: fe523a91e6cc71d3de0a42fc592c1ccd21337b67d2aa2355f1da85b7428f06a8
 SHA512:
-  metadata.gz: 2dc4fe2223f141e4283eab56f517dc1611844436fe9a8ef0d60f7924a7e52c6276cc15d385c16873c96c697398e0dd03c949c1fe0a00fbef69efceedbfd6ea5f
-  data.tar.gz: 07ef3e6827676dd054b80895b8beb89a4d7394ca5c4e658494fbf3fed320b564b89749d877e8cfa54621aad4f49112bca0f76713874480d6fc597ff313f128c8
+  metadata.gz: 162fe8eb9540ee3d3ca709b8ddf5554bd58bfae2188af5e74d1b9505113d29cc31cee58482d9cbf53b38cd3f4ae6d1d4dde31108862d08a552e42767131000cc
+  data.tar.gz: c16fb85269cf137f8d55443b9e1337b56d20f46de9cd0d816bf3b24c41faa5abd343b6b648d84f27a0eea2f326223b746ea4042dcaad201717fbad703bf2dff4

data/.yardopts

@@ -0,0 +1,8 @@
+--title "Frausto Documentation"
+--markup markdown
+--readme README.md
+lib/**/*.rb
+-
+ruby2faust.md
+faust2ruby.md
+LICENSE.txt

data/README.md

@@ -1,5 +1,10 @@
 # Frausto
 
+[![Gem Version](https://badge.fury.io/rb/frausto.svg)](https://rubygems.org/gems/frausto)
+[![CI](https://github.com/dfl/ruby2faust/actions/workflows/ci.yml/badge.svg)](https://github.com/dfl/ruby2faust/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.0-ruby.svg)](https://www.ruby-lang.org)
+
 A Ruby toolkit for Faust DSP: generate Faust code from Ruby, or convert Faust to Ruby.
 
 ## Installation
@@ -19,25 +24,37 @@ gem 'frausto'
 - **[ruby2faust](ruby2faust.md)** - Ruby DSL that generates Faust DSP code
 - **[faust2ruby](faust2ruby.md)** - Convert Faust DSP code to Ruby DSL
 
-## Quick Example
+## Quick Examples
 
 ```ruby
 require 'ruby2faust'
 
 code = Ruby2Faust.generate do
-  osc(440) >> lp(800) >> gain(0.3)
+  freq = 60.midi >> smoo
+  -6.db * ((osc(freq) + 0.1 * noise) >> lp(2000))
 end
 
 puts code
 # => import("stdfaust.lib");
-#    process = (os.osc(440) : fi.lowpass(1, 800) : *(0.3));
+#    process = os.osc(ba.midikey2hz(60) : si.smoo) + (no.noise : *(0.1)) : fi.lowpass(1, 2000) : *(ba.db2linear(-6));
+
+# Use pretty: true for readable output
+puts Ruby2Faust.generate(pretty: true) { -6.db * ((osc(60.midi >> smoo) + 0.1 * noise) >> lp(2000)) }
+# => import("stdfaust.lib");
+#    process =
+#      os.osc(
+#        ba.midikey2hz(60)
+#        : si.smoo
+#      ) + (no.noise : *(0.1))
+#      : fi.lowpass(1, 2000)
+#      : *(ba.db2linear(-6));
 ```
 
 ```ruby
 require 'faust2ruby'
 
 ruby_code = Faust2Ruby.to_ruby('process = os.osc(440) : *(0.5);')
-# => "osc(440) >> gain(0.5)"
+# => "0.5 * osc(440)"
 ```
 
 ## License

data/lib/faust2ruby/ruby_generator.rb

@@ -347,7 +347,17 @@ module Faust2Ruby
 
       case node.op
       when :SEQ
-        "(#{left} >> #{right})"
+        # Idiomatic Ruby: signal : *(x) becomes x * signal
+        if node.right.is_a?(AST::FunctionCall) && node.right.name == "*" && node.right.args.length == 1
+          arg = generate_expression(node.right.args[0])
+          "(#{arg} * #{left})"
+        # Idiomatic Ruby: signal : /(x) becomes signal / x
+        elsif node.right.is_a?(AST::FunctionCall) && node.right.name == "/" && node.right.args.length == 1
+          arg = generate_expression(node.right.args[0])
+          "(#{left} / #{arg})"
+        else
+          "(#{left} >> #{right})"
+        end
       when :PAR
         "(#{left} | #{right})"
       when :SPLIT
@@ -463,6 +473,32 @@ module Faust2Ruby
         # ba.selectn(n, idx, ...) -> selectn(n, idx, ...)
         "selectn(#{args.join(', ')})"
 
+      when :db2linear
+        # ba.db2linear(-6) -> -6.db (idiomatic Ruby)
+        # Handle both "-6" and "(-6)" forms
+        arg = args[0]&.gsub(/\A\(|\)\z/, '') # strip outer parens
+        if args.length == 1 && arg&.match?(/\A-?\d+\.?\d*\z/)
+          "#{arg}.db"
+        else
+          "db2linear(#{args.join(', ')})"
+        end
+
+      when :midi2hz
+        # ba.midikey2hz(60) -> 60.midi (idiomatic Ruby)
+        if args.length == 1 && args[0].match?(/\A\d+\.?\d*\z/)
+          "#{args[0]}.midi"
+        else
+          "midi2hz(#{args.join(', ')})"
+        end
+
+      when :sec2samp
+        # ba.sec2samp(0.1) -> 0.1.sec (idiomatic Ruby)
+        if args.length == 1 && args[0].match?(/\A\d+\.?\d*\z/)
+          "#{args[0]}.sec"
+        else
+          "sec2samp(#{args.join(', ')})"
+        end
+
       else
         # Standard call - check for partial application
         expected_args = mapping[:args]

data/lib/ruby2faust/dsl.rb

@@ -72,6 +72,14 @@ module Ruby2Faust
       "#<Ruby2Faust::DSP #{to_s}>"
     end
 
+    # Enable numeric-on-left operations like: 0.3 * osc(440)
+    # Ruby calls coerce when left operand doesn't know how to handle right operand
+    # @param other [Numeric]
+    # @return [Array<DSP, DSP>]
+    def coerce(other)
+      [DSL.to_dsp(other), self]
+    end
+
     # Add / mix signals (Faust +)
     # @param other [Numeric, DSP, Symbol]
     # @return [DSP]

data/lib/ruby2faust/emitter.rb

@@ -9,6 +9,41 @@ module Ruby2Faust
 
     DEFAULT_IMPORTS = ["stdfaust.lib"].freeze
 
+    # Scalar types produce constant values (not signal processors)
+    SCALAR_TYPES = [
+      NodeType::DB2LINEAR, NodeType::LINEAR2DB,
+      NodeType::MIDI2HZ, NodeType::HZ2MIDI,
+      NodeType::SEC2SAMP, NodeType::SAMP2SEC
+    ].freeze
+
+    # Operator precedence (higher = binds tighter)
+    PREC = {
+      seq: 1,      # :
+      par: 2,      # ,
+      split: 3,    # <:
+      merge: 3,    # :>
+      rec: 4,      # ~
+      add: 5,      # +
+      sub: 5,      # -
+      mul: 6,      # *
+      div: 6,      # /
+      mod: 6,      # %
+      cmp: 7,      # < > <= >= == !=
+      primary: 100 # literals, function calls - never need parens
+    }.freeze
+
+    # Check if a node represents a scalar/constant value
+    def scalar?(node)
+      return true if SCALAR_TYPES.include?(node.type)
+      return true if node.type == NodeType::LITERAL && node.args[0].to_s.match?(/\A-?\d+\.?\d*\z/)
+      false
+    end
+
+    # Wrap expression in parens if needed based on precedence
+    def wrap(expr, my_prec, parent_prec)
+      my_prec < parent_prec ? "(#{expr})" : expr
+    end
+
     def program(process, imports: nil, declarations: {}, pretty: false)
       if process.is_a?(Program)
         node = process.process.is_a?(DSP) ? process.process.node : process.process
@@ -25,12 +60,12 @@ module Ruby2Faust
       imports.each { |lib| lines << "import(\"#{lib}\");" }
       lines << ""
       
-      body = emit(node, pretty: pretty)
+      body = emit(node, pretty: pretty, prec: 0)
       lines << "process = #{body};"
       lines.join("\n") + "\n"
     end
 
-    def emit(node, indent: 0, pretty: false)
+    def emit(node, indent: 0, pretty: false, prec: 0)
       sp = "  " * indent
       next_sp = "  " * (indent + 1)
 
@@ -173,13 +208,64 @@ module Ruby2Faust
       when NodeType::GAIN
         "*(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
       when NodeType::ADD
-        node.inputs.count == 2 ? "(#{emit(node.inputs[0], indent: indent, pretty: pretty)} + #{emit(node.inputs[1], indent: indent, pretty: pretty)})" : "+"
+        if node.inputs.count == 2
+          my_prec = PREC[:add]
+          left = emit(node.inputs[0], indent: indent, pretty: pretty, prec: my_prec)
+          right = emit(node.inputs[1], indent: indent, pretty: pretty, prec: my_prec + 1)
+          wrap("#{left} + #{right}", my_prec, prec)
+        else
+          "+"
+        end
       when NodeType::MUL
-        node.inputs.count == 2 ? "(#{emit(node.inputs[0], indent: indent, pretty: pretty)} * #{emit(node.inputs[1], indent: indent, pretty: pretty)})" : "*"
+        if node.inputs.count == 2
+          left_node, right_node = node.inputs
+          # Normalize: signal : *(scalar) - idiomatic Faust gain (uses SEQ precedence)
+          if scalar?(right_node) && !scalar?(left_node)
+            my_prec = PREC[:seq]
+            left = emit(left_node, indent: indent, pretty: pretty, prec: my_prec)
+            right = emit(right_node, indent: indent, pretty: pretty, prec: PREC[:primary])
+            wrap("#{left} : *(#{right})", my_prec, prec)
+          elsif scalar?(left_node) && !scalar?(right_node)
+            my_prec = PREC[:seq]
+            left = emit(right_node, indent: indent, pretty: pretty, prec: my_prec)
+            right = emit(left_node, indent: indent, pretty: pretty, prec: PREC[:primary])
+            wrap("#{left} : *(#{right})", my_prec, prec)
+          else
+            my_prec = PREC[:mul]
+            left = emit(left_node, indent: indent, pretty: pretty, prec: my_prec)
+            right = emit(right_node, indent: indent, pretty: pretty, prec: my_prec + 1)
+            wrap("#{left} * #{right}", my_prec, prec)
+          end
+        else
+          "*"
+        end
       when NodeType::SUB
-        node.inputs.count == 2 ? "(#{emit(node.inputs[0], indent: indent, pretty: pretty)} - #{emit(node.inputs[1], indent: indent, pretty: pretty)})" : "-"
+        if node.inputs.count == 2
+          my_prec = PREC[:sub]
+          left = emit(node.inputs[0], indent: indent, pretty: pretty, prec: my_prec)
+          right = emit(node.inputs[1], indent: indent, pretty: pretty, prec: my_prec + 1)
+          wrap("#{left} - #{right}", my_prec, prec)
+        else
+          "-"
+        end
       when NodeType::DIV
-        node.inputs.count == 2 ? "(#{emit(node.inputs[0], indent: indent, pretty: pretty)} / #{emit(node.inputs[1], indent: indent, pretty: pretty)})" : "/"
+        if node.inputs.count == 2
+          left_node, right_node = node.inputs
+          # Idiomatic Faust: signal : /(scalar) (uses SEQ precedence)
+          if scalar?(right_node) && !scalar?(left_node)
+            my_prec = PREC[:seq]
+            left = emit(left_node, indent: indent, pretty: pretty, prec: my_prec)
+            right = emit(right_node, indent: indent, pretty: pretty, prec: PREC[:primary])
+            wrap("#{left} : /(#{right})", my_prec, prec)
+          else
+            my_prec = PREC[:div]
+            left = emit(left_node, indent: indent, pretty: pretty, prec: my_prec)
+            right = emit(right_node, indent: indent, pretty: pretty, prec: my_prec + 1)
+            wrap("#{left} / #{right}", my_prec, prec)
+          end
+        else
+          "/"
+        end
       when NodeType::MOD
         "(#{emit(node.inputs[0], indent: indent, pretty: pretty)} % #{emit(node.inputs[1], indent: indent, pretty: pretty)})"
 
@@ -436,45 +522,57 @@ module Ruby2Faust
 
       # === COMPOSITION ===
       when NodeType::SEQ
-        left = emit(node.inputs[0], indent: indent + 1, pretty: pretty)
-        right = emit(node.inputs[1], indent: indent + 1, pretty: pretty)
-        if pretty
-          "(\n#{next_sp}#{left}\n#{next_sp}: #{right}\n#{sp})"
+        my_prec = PREC[:seq]
+        # Left child: same precedence (left-associative, no parens needed)
+        # Right child: higher precedence required (would need parens if it's another SEQ)
+        left = emit(node.inputs[0], indent: indent + 1, pretty: pretty, prec: my_prec)
+        right = emit(node.inputs[1], indent: indent + 1, pretty: pretty, prec: my_prec + 1)
+        expr = if pretty
+          "\n#{next_sp}#{left}\n#{next_sp}: #{right}\n#{sp}"
         else
-          "(#{left} : #{right})"
+          "#{left} : #{right}"
         end
+        wrap(expr, my_prec, prec)
       when NodeType::PAR
-        left = emit(node.inputs[0], indent: indent + 1, pretty: pretty)
-        right = emit(node.inputs[1], indent: indent + 1, pretty: pretty)
-        if pretty
-          "(\n#{next_sp}#{left},\n#{next_sp}#{right}\n#{sp})"
+        my_prec = PREC[:par]
+        left = emit(node.inputs[0], indent: indent + 1, pretty: pretty, prec: my_prec)
+        right = emit(node.inputs[1], indent: indent + 1, pretty: pretty, prec: my_prec + 1)
+        expr = if pretty
+          "\n#{next_sp}#{left},\n#{next_sp}#{right}\n#{sp}"
         else
-          "(#{left}, #{right})"
+          "#{left}, #{right}"
         end
+        wrap(expr, my_prec, prec)
       when NodeType::SPLIT
-        source = emit(node.inputs[0], indent: indent + 1, pretty: pretty)
-        targets = node.inputs[1..].map { |n| emit(n, indent: indent + 1, pretty: pretty) }
-        if pretty
-          "(\n#{next_sp}#{source}\n#{next_sp}<: #{targets.join(",\n#{next_sp}   ")}\n#{sp})"
+        my_prec = PREC[:split]
+        source = emit(node.inputs[0], indent: indent + 1, pretty: pretty, prec: my_prec)
+        targets = node.inputs[1..].map { |n| emit(n, indent: indent + 1, pretty: pretty, prec: my_prec + 1) }
+        expr = if pretty
+          "\n#{next_sp}#{source}\n#{next_sp}<: #{targets.join(",\n#{next_sp}   ")}\n#{sp}"
         else
-          "(#{source} <: #{targets.join(", ")})"
+          "#{source} <: #{targets.join(", ")}"
         end
+        wrap(expr, my_prec, prec)
       when NodeType::MERGE
-        left = emit(node.inputs[0], indent: indent + 1, pretty: pretty)
-        right = emit(node.inputs[1], indent: indent + 1, pretty: pretty)
-        if pretty
-          "(\n#{next_sp}#{left}\n#{next_sp}:> #{right}\n#{sp})"
+        my_prec = PREC[:merge]
+        left = emit(node.inputs[0], indent: indent + 1, pretty: pretty, prec: my_prec)
+        right = emit(node.inputs[1], indent: indent + 1, pretty: pretty, prec: my_prec + 1)
+        expr = if pretty
+          "\n#{next_sp}#{left}\n#{next_sp}:> #{right}\n#{sp}"
         else
-          "(#{left} :> #{right})"
+          "#{left} :> #{right}"
         end
+        wrap(expr, my_prec, prec)
       when NodeType::FEEDBACK
-        left = emit(node.inputs[0], indent: indent + 1, pretty: pretty)
-        right = emit(node.inputs[1], indent: indent + 1, pretty: pretty)
-        if pretty
-          "(\n#{next_sp}#{left}\n#{next_sp}~ #{right}\n#{sp})"
+        my_prec = PREC[:rec]
+        left = emit(node.inputs[0], indent: indent + 1, pretty: pretty, prec: my_prec)
+        right = emit(node.inputs[1], indent: indent + 1, pretty: pretty, prec: my_prec + 1)
+        expr = if pretty
+          "\n#{next_sp}#{left}\n#{next_sp}~ #{right}\n#{sp}"
         else
-          "(#{left} ~ #{right})"
+          "#{left} ~ #{right}"
         end
+        wrap(expr, my_prec, prec)
 
       # === UTILITY ===
       when NodeType::WIRE

data/lib/ruby2faust/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruby2Faust
-  VERSION = "0.2.0"
+  VERSION = "0.2.3"
 end

data/ruby2faust.md

@@ -34,9 +34,10 @@ Ruby2Faust maps Faust's composition operators to Ruby methods and operators:
 # Sequential: signal flows through a chain
 osc(440) >> lp(800) >> gain(0.3)      
 
-# Arithmetic operators (Infix)
+# Arithmetic operators (Infix) - work with numeric on either side
 osc(440) + noise                        # Mix / Sum
 osc(440) * 0.3                          # Gain
+0.3 * osc(440)                          # Gain (numeric on left)
 osc(440) - osc(442)                     # Subtraction
 -osc(440)                               # Negate
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: frausto
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.3
 platform: ruby
 authors:
 - David Lowenfels
 bindir: bin
 cert_chain: []
-date: 2026-01-20 00:00:00.000000000 Z
+date: 2026-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -61,6 +61,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".yardopts"
 - LICENSE.txt
 - README.md
 - bin/faust2ruby