frausto 0.2.0

data/lib/ruby2faust/ir.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Ruby2Faust
+  # Intermediate Representation node for DSP graphs.
+  # Nodes are immutable value objects representing DSP operations.
+  Node = Struct.new(:type, :args, :inputs, :channels, keyword_init: true) do
+    def initialize(type:, args: [], inputs: [], channels: 1)
+      super(type: type, args: args.freeze, inputs: inputs.freeze, channels: channels)
+    end
+
+    def fingerprint
+      content = [type, args, inputs.map(&:fingerprint)].inspect
+      Digest::SHA1.hexdigest(content)
+    end
+
+    def same_structure?(other)
+      fingerprint == other.fingerprint
+    end
+  end
+
+  # Node type constants - comprehensive Faust library coverage
+  module NodeType
+    # === Comments/Documentation ===
+    COMMENT = :comment  # // line comment
+    DOC     = :doc      # /* inline comment */ attached to node
+
+    # === Oscillators (os.) ===
+    OSC       = :osc        # os.osc(freq) - sine
+    SAW       = :saw        # os.sawtooth(freq)
+    SQUARE    = :square     # os.square(freq)
+    TRIANGLE  = :triangle   # os.triangle(freq)
+    PHASOR    = :phasor     # os.phasor(tablesize, freq)
+    LF_SAW    = :lf_saw     # os.lf_sawpos(freq) - low-freq sawtooth 0-1
+    LF_TRIANGLE = :lf_triangle
+    LF_SQUARE = :lf_square
+    IMPTRAIN  = :imptrain   # os.lf_imptrain(freq) - impulse train
+    PULSETRAIN = :pulsetrain # os.lf_pulsetrain(freq, duty)
+
+    # === Noise (no.) ===
+    NOISE      = :noise      # no.noise - white
+    PINK_NOISE = :pink_noise # no.pink_noise
+
+    # === Filters (fi.) ===
+    LP = :lp  # fi.lowpass(order, freq)
+    HP = :hp  # fi.highpass(order, freq)
+    BP = :bp  # fi.bandpass(order, freq, q)
+    RESONLP = :resonlp  # fi.resonlp(freq, q, gain)
+    RESONHP = :resonhp
+    RESONBP = :resonbp
+    ALLPASS = :allpass  # fi.allpass_comb(maxdelay, delay, feedback)
+    DCBLOCK = :dcblock  # fi.dcblocker
+    PEAK_EQ = :peak_eq  # fi.peak_eq(freq, q, gain_db)
+
+    # SVF (State Variable Filter)
+    SVF_LP    = :svf_lp    # fi.svf.lp(freq, q)
+    SVF_HP    = :svf_hp    # fi.svf.hp(freq, q)
+    SVF_BP    = :svf_bp    # fi.svf.bp(freq, q)
+    SVF_NOTCH = :svf_notch # fi.svf.notch(freq, q)
+    SVF_AP    = :svf_ap    # fi.svf.ap(freq, q)
+    SVF_BELL  = :svf_bell  # fi.svf.bell(freq, q, gain)
+    SVF_LS    = :svf_ls    # fi.svf.ls(freq, q, gain) - low shelf
+    SVF_HS    = :svf_hs    # fi.svf.hs(freq, q, gain) - high shelf
+
+    # Other filters
+    LOWPASS3E  = :lowpass3e   # fi.lowpass3e(freq) - 3rd order elliptic
+    HIGHPASS3E = :highpass3e  # fi.highpass3e(freq)
+    LOWPASS6E  = :lowpass6e   # fi.lowpass6e(freq) - 6th order elliptic
+    HIGHPASS6E = :highpass6e  # fi.highpass6e(freq)
+    BANDSTOP   = :bandstop    # fi.bandstop(order, freq, q)
+    NOTCHW     = :notchw      # fi.notchw(freq, width)
+    LOW_SHELF  = :low_shelf   # fi.low_shelf(freq, q, gain)
+    HIGH_SHELF = :high_shelf  # fi.high_shelf(freq, q, gain)
+    PEAK_EQ_CQ = :peak_eq_cq  # fi.peak_eq_cq(freq, q, gain)
+    FI_POLE    = :fi_pole     # fi.pole(p)
+    FI_ZERO    = :fi_zero     # fi.zero(z)
+    TF1        = :tf1         # fi.tf1(b0, b1, a1)
+    TF2        = :tf2         # fi.tf2(b0, b1, b2, a1, a2)
+    TF1S       = :tf1s        # fi.tf1s(b0, b1, a1)
+    TF2S       = :tf2s        # fi.tf2s(b0, b1, b2, a1, a2)
+    IIR        = :iir         # fi.iir(bcoeffs, acoeffs)
+    FIR        = :fir         # fi.fir(coeffs)
+    CONV       = :conv        # fi.conv(impulse, size)
+    FBCOMBFILTER = :fbcombfilter # fi.fbcombfilter(maxdel, del, fb)
+    FFCOMBFILTER = :ffcombfilter # fi.ffcombfilter(maxdel, del)
+
+    # === Delays (de.) ===
+    DELAY  = :delay   # de.delay(maxdelay, delay)
+    FDELAY = :fdelay  # de.fdelay(maxdelay, delay) - fractional
+    SDELAY = :sdelay  # de.sdelay(maxdelay, interp, delay) - smooth
+
+    # === Envelopes (en.) ===
+    AR    = :ar    # en.ar(attack, release, gate)
+    ASR   = :asr   # en.asr(attack, sustain_level, release, gate)
+    ADSR  = :adsr  # en.adsr(attack, decay, sustain, release, gate)
+    ADSRE = :adsre # en.adsre with exponential segments
+
+    # === Math (primitives + ma.) ===
+    GAIN = :gain       # *(x)
+    ADD  = :add        # +
+    MUL  = :mul        # *
+    SUB  = :sub        # -
+    DIV  = :div        # /
+    NEG  = :neg        # 0 - x
+    ABS  = :abs        # abs
+    MIN  = :min        # min(a, b)
+    MAX  = :max        # max(a, b)
+    CLIP = :clip       # max(min_val, min(max_val, x))
+    POW  = :pow        # pow(base, exp)
+    SQRT = :sqrt       # sqrt
+    EXP  = :exp        # exp
+    LOG  = :log        # log
+    LOG10 = :log10     # log10
+    SIN  = :sin        # sin
+    COS  = :cos        # cos
+    TAN  = :tan        # tan
+    ASIN = :asin
+    ACOS = :acos
+    ATAN = :atan
+    ATAN2 = :atan2
+    TANH = :tanh       # ma.tanh - saturating
+    SINH = :sinh
+    COSH = :cosh
+    ASINH = :asinh
+    ACOSH = :acosh
+    ATANH = :atanh
+    FLOOR = :floor
+    CEIL = :ceil
+    RINT = :rint       # round to int
+    FMOD = :fmod       # fmod(x, y)
+    REMAINDER = :remainder
+    MOD  = :mod        # %
+
+    # === Comparison ===
+    LT  = :lt   # <
+    GT  = :gt   # >
+    LE  = :le   # <=
+    GE  = :ge   # >=
+    EQ  = :eq   # ==
+    NEQ = :neq  # !=
+
+    # === Bitwise ===
+    BAND = :band  # &
+    BOR  = :bor   # | (bitwise, not parallel)
+    XOR  = :xor   # xor
+
+    # === Conversion (ba.) ===
+    DB2LINEAR = :db2linear  # ba.db2linear
+    LINEAR2DB = :linear2db  # ba.linear2db
+    SAMP2SEC  = :samp2sec   # ba.samp2sec
+    SEC2SAMP  = :sec2samp   # ba.sec2samp
+    MIDI2HZ   = :midi2hz    # ba.midikey2hz
+    HZ2MIDI   = :hz2midi    # ba.hz2midikey
+    TAU2POLE  = :tau2pole   # ba.tau2pole
+    POLE2TAU  = :pole2tau   # ba.pole2tau
+    BA_IF     = :ba_if      # ba.if(cond, then, else)
+    SELECTOR  = :selector   # ba.selector(n, sel, inputs)
+    BA_TAKE   = :ba_take    # ba.take(idx, tuple)
+
+    # === Smoothing (si.) ===
+    SMOOTH    = :smooth     # si.smooth(ba.tau2pole(tau))
+    SMOO      = :smoo       # si.smoo - default 5ms smooth
+    POLYSMOOTH = :polysmooth # si.polySmooth(s, n)
+
+    # === Selectors ===
+    SELECT2 = :select2  # select2(cond, a, b)
+    SELECTN = :selectn  # ba.selectn(n, idx, ...)
+
+    # === Routing (si./ro.) ===
+    BUS   = :bus    # si.bus(n) - n parallel wires
+    BLOCK = :block  # si.block(n) - terminate n signals
+
+    # === Reverbs (re.) ===
+    FREEVERB = :freeverb  # re.mono_freeverb(fb1, fb2, damp, spread)
+    ZITA_REV = :zita_rev  # re.zita_rev1_stereo(...)
+    JPVERB   = :jpverb    # re.jpverb(...)
+
+    # === Compressors (co.) ===
+    COMPRESSOR = :compressor  # co.compressor_mono(ratio, thresh, attack, release)
+    LIMITER    = :limiter     # co.limiter_1176_R4_mono
+
+    # === Spatial (sp.) ===
+    PANNER = :panner  # sp.panner(pan) - stereo pan
+
+    # === UI Controls ===
+    SLIDER   = :slider
+    VSLIDER  = :vslider
+    NENTRY   = :nentry
+    BUTTON   = :button
+    CHECKBOX = :checkbox
+    HGROUP   = :hgroup
+    VGROUP   = :vgroup
+    TGROUP   = :tgroup
+
+    # === Composition ===
+    SEQ      = :seq       # :
+    PAR      = :par       # ,
+    SPLIT    = :split     # <:
+    MERGE    = :merge     # :>
+    FEEDBACK = :feedback  # ~
+    REC      = :rec       # letrec style
+    LETREC   = :letrec    # letrec { 'x = expr; 'y = expr; } result
+
+    # === Iteration ===
+    FPAR  = :fpar   # par(i, n, expr)
+    FSEQ  = :fseq   # seq(i, n, expr)
+    FSUM  = :fsum   # sum(i, n, expr)
+    FPROD = :fprod  # prod(i, n, expr)
+
+    # === Lambda ===
+    LAMBDA = :lambda  # \(x).(body)
+    PARAM  = :param   # Parameter reference
+
+    # === Tables ===
+    RDTABLE  = :rdtable   # rdtable(n, init, ridx)
+    RWTABLE  = :rwtable   # rwtable(n, init, widx, wsig, ridx)
+    WAVEFORM = :waveform  # waveform{...}
+
+    # === Additional Routing ===
+    ROUTE   = :route    # route(ins, outs, connections)
+    SELECT3 = :select3  # select3(sel, a, b, c)
+
+    # === Utility ===
+    WIRE    = :wire    # _
+    CUT     = :cut     # !
+    LITERAL = :literal # raw Faust expression
+    MEM     = :mem     # mem (1-sample delay)
+    INT     = :int     # int(x)
+    FLOAT   = :float   # float(x)
+
+    # === Constants ===
+    SR = :sr      # ma.SR
+    PI = :pi      # ma.PI
+    TEMPO = :tempo # ma.tempo
+
+    # === Antialiasing (aa.) ===
+    AA_TANH1    = :aa_tanh1    # aa.tanh1
+    AA_TANH2    = :aa_tanh2    # aa.tanh2
+    AA_ARCTAN   = :aa_arctan   # aa.arctan
+    AA_SOFTCLIP = :aa_softclip # aa.softclip
+    AA_HARDCLIP = :aa_hardclip # aa.hardclip
+    AA_PARABOLIC = :aa_parabolic # aa.parabolic
+    AA_SIN      = :aa_sin      # aa.sin
+    AA_CUBIC1   = :aa_cubic1   # aa.cubic1
+    AA_CUBIC2   = :aa_cubic2   # aa.cubic2
+
+    # === Analyzers (an.) ===
+    AMP_FOLLOWER      = :amp_follower       # an.amp_follower(t)
+    AMP_FOLLOWER_AR   = :amp_follower_ar    # an.amp_follower_ar(attack, release)
+    AMP_FOLLOWER_UD   = :amp_follower_ud    # an.amp_follower_ud(up, down)
+    RMS_ENVELOPE_RECT = :rms_envelope_rect  # an.rms_envelope_rect(period)
+    RMS_ENVELOPE_TAU  = :rms_envelope_tau   # an.rms_envelope_tau(tau)
+    ABS_ENVELOPE_RECT = :abs_envelope_rect  # an.abs_envelope_rect(period)
+    ABS_ENVELOPE_TAU  = :abs_envelope_tau   # an.abs_envelope_tau(tau)
+    MS_ENVELOPE_RECT  = :ms_envelope_rect   # an.ms_envelope_rect(period)
+    MS_ENVELOPE_TAU   = :ms_envelope_tau    # an.ms_envelope_tau(tau)
+    PEAK_ENVELOPE     = :peak_envelope      # an.peak_envelope(t)
+
+    # === Effects (ef.) ===
+    CUBICNL            = :cubicnl             # ef.cubicnl(drive, offset)
+    GATE_MONO          = :gate_mono           # ef.gate_mono(thresh, att, hold, rel)
+    GATE_STEREO        = :gate_stereo         # ef.gate_stereo(thresh, att, hold, rel)
+    EF_COMPRESSOR_MONO   = :ef_compressor_mono   # ef.compressor_mono
+    EF_COMPRESSOR_STEREO = :ef_compressor_stereo # ef.compressor_stereo
+    EF_LIMITER_1176_MONO   = :ef_limiter_1176_mono   # ef.limiter_1176_R4_mono
+    EF_LIMITER_1176_STEREO = :ef_limiter_1176_stereo # ef.limiter_1176_R4_stereo
+    ECHO               = :echo                # ef.echo(maxdel, del, fb)
+    TRANSPOSE          = :transpose           # ef.transpose(w, x, s)
+    FLANGER_MONO       = :flanger_mono        # ef.flanger_mono(...)
+    FLANGER_STEREO     = :flanger_stereo      # ef.flanger_stereo(...)
+    PHASER2_MONO       = :phaser2_mono        # ef.phaser2_mono(...)
+    PHASER2_STEREO     = :phaser2_stereo      # ef.phaser2_stereo(...)
+    WAH4               = :wah4                # ef.wah4(fr)
+    AUTO_WAH           = :auto_wah            # ef.auto_wah(level)
+    CRYBABY            = :crybaby             # ef.crybaby(wah)
+    VOCODER            = :vocoder             # ef.vocoder(bands, range)
+    SPEAKERBP          = :speakerbp           # ef.speakerbp(flo, fhi)
+    DRY_WET_MIXER      = :dry_wet_mixer       # ef.dryWetMixer(mix)
+    DRY_WET_MIXER_CP   = :dry_wet_mixer_cp    # ef.dryWetMixerConstantPower(mix)
+
+    # === Metadata ===
+    DECLARE = :declare
+  end
+end

data/lib/ruby2faust/live.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "ir"
+require_relative "emitter"
+
+module Ruby2Faust
+  # Live reload support: graph diffing, compilation, crossfade.
+  module Live
+    module_function
+
+    # Check if two graphs have different structure
+    #
+    # @param old_graph [DSP, Node] Previous graph
+    # @param new_graph [DSP, Node] New graph
+    # @return [Boolean] True if structures differ
+    def changed?(old_graph, new_graph)
+      old_node = old_graph.is_a?(DSP) ? old_graph.node : old_graph
+      new_node = new_graph.is_a?(DSP) ? new_graph.node : new_graph
+      !old_node.same_structure?(new_node)
+    end
+
+    # Compile a DSP graph to a Faust file
+    #
+    # @param graph [DSP] The DSP graph to compile
+    # @param output [String] Output file path (.dsp)
+    # @param imports [Array<String>] Libraries to import
+    # @return [String] Path to the output file
+    def compile(graph, output:, imports: Emitter::DEFAULT_IMPORTS)
+      code = Emitter.program(graph, imports: imports)
+      File.write(output, code)
+      output
+    end
+
+    # Generate crossfade DSP code for smooth transitions
+    # Creates a Faust program that crossfades between old and new DSP
+    #
+    # @param old_process [String] Faust expression for old process
+    # @param new_process [String] Faust expression for new process
+    # @param duration [Float] Crossfade duration in seconds (default 0.05)
+    # @return [String] Faust source with crossfade
+    def crossfade_dsp(old_process, new_process, duration: 0.05)
+      <<~FAUST
+        import("stdfaust.lib");
+
+        // Crossfade envelope
+        xfade = hslider("xfade", 0, 0, 1, 0.001) : si.smoo;
+
+        // Old and new processes
+        old = #{old_process};
+        new = #{new_process};
+
+        // Crossfade: (1-x)*old + x*new
+        process = old * (1 - xfade), new * xfade :> _;
+      FAUST
+    end
+
+    # Run the Faust compiler on a .dsp file
+    # Requires faust to be in PATH
+    #
+    # @param dsp_file [String] Path to .dsp file
+    # @param target [Symbol] Compilation target (:wasm, :cpp, :llvm)
+    # @param output_dir [String] Output directory (default: same as input)
+    # @return [Boolean] True if compilation succeeded
+    def faust_compile(dsp_file, target: :cpp, output_dir: nil)
+      output_dir ||= File.dirname(dsp_file)
+      basename = File.basename(dsp_file, ".dsp")
+
+      cmd = case target
+            when :wasm
+              "faust2wasm #{dsp_file} -o #{output_dir}/#{basename}.wasm"
+            when :cpp
+              "faust -a minimal.cpp #{dsp_file} -o #{output_dir}/#{basename}.cpp"
+            when :llvm
+              "faust -lang llvm #{dsp_file} -o #{output_dir}/#{basename}.ll"
+            else
+              raise ArgumentError, "Unknown target: #{target}"
+            end
+
+      system(cmd)
+    end
+  end
+end

data/lib/ruby2faust/version.rb

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

data/lib/ruby2faust.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "ruby2faust/version"
+require_relative "ruby2faust/ir"
+require_relative "ruby2faust/dsl"
+require_relative "ruby2faust/emitter"
+require_relative "ruby2faust/live"
+
+module Ruby2Faust
+  class Error < StandardError; end
+
+  # Convenience method to generate Faust code from a block
+  #
+  # @example
+  #   code = Ruby2Faust.generate do
+  #     osc(440).then(gain(0.3))
+  #   end
+  #
+  # @yield Block that returns a DSP
+  # @return [String] Faust source code
+  def self.generate(pretty: false, &block)
+    context = Object.new
+    context.extend(DSL)
+    process = context.instance_eval(&block)
+    Emitter.program(process, pretty: pretty)
+  end
+end