chaussettes 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 09fa2339e4fa515bb12f28671bb4198871087411
+  data.tar.gz: bc3d65c38875e6a6c340aabe21fc1103e790e0f3
+SHA512:
+  metadata.gz: d1afb30a879e137ccfd6a92815e38f4082238da02aa98fb17f53f255abd6edb918f3ac76f29513ed6c366da33d63e352375fe0f7f98bbbc811e364072e200fc2
+  data.tar.gz: 0c87fb7238943af3ace082520b8957c12e29b338575c5484ea2c73cb8a5807188989c648d08cddebed35111bca5247e28b79d443c265951901d4461e699c35fa

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Jamis Buck
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,120 @@
+# Chaussettes
+
+Chaussettes is a wrapper around the command-line `sox` utility. It enables you
+to manipulate audio by programmatically constructing a sox operation, including
+multiple effect chains and various supported input and output streams.
+
+
+## Installation
+
+Simply gem install it.
+
+    $ gem install chaussettes
+
+It has no other dependencies, although it won't work
+very well if you don't also install `sox`, which you can grab here: http://sox.sourceforge.net/.
+
+
+## Usage
+
+To find out information about an existing clip, you can use the
+`Chaussettes::Info` class:
+
+```ruby
+require 'chaussettes'
+
+info = Chaussettes::Info.new('hello.mp3')
+p info.duration # 192.3 (seconds)
+```
+
+To programmatically construct a sox command-line, use the `Chaussettes::Clip`
+class:
+
+```ruby
+require 'chaussettes'
+
+clip = Chaussettes::Clip.new do |c|
+  c.mix
+  c.in 'music-track.mp3'
+  c.in 'narration.wav'
+  c.out 'soundtrack.wav'
+end
+
+clip.run
+# sox --combine mix music-track.mp3 narration.wav soundtrack.wav
+```
+
+Each input and output can also accept options, which ought to be chained onto
+the corresponding input:
+
+```ruby
+clip = Chaussettes::Clip.new do |c|
+  c.mix
+  c.in('music-track.mp3').volume(0.5)
+  c.in 'narration.wav'
+  c.out('soundtrack.wav').bits(16).rate(44_100).channels(2)
+end
+
+clip.run
+# sox --combine mix \
+#     --volume 0.5 music-track.mp3 \
+#     narration.wav \
+#     --bits 16 --rate 44100 --channels 2 soundtrack.wav
+```
+
+Furthermore, you can also chain effects to the clip:
+
+```ruby
+clip = Chaussettes::Clip.new do |c|
+  c.mix
+  c.in 'music-track.mp3'
+  c.in 'narration.wav'
+  c.out 'soundtrack.wav'
+  c.chain.trim(0, 10).pad(1.5)
+end
+# sox --combine mix \
+#     music-track.mp3 narration.wav soundtrack.wav \
+#     trim 0 10 pad 1.5
+```
+_(Note that not all effects supported by sox are implemented by Chaussettes...yet)_
+
+And multiple effect chains may be applied, for potentially complex effects:
+
+```ruby
+clip = Chaussettes::Clip.new do |c|
+  c.mix
+  c.in 'music-track.mp3'
+  c.in 'narration.wav'
+  c.out 'soundtrack.wav'
+  c.chain.trim(0, 10).pad(1.5)
+  c.chain.newfile
+  c.chain.restart
+end
+# sox --combine mix \
+#     music-track.mp3 narration.wav soundtrack.wav \
+#     trim 0 10 pad 1.5 : newfile : restart
+```
+
+Inputs may be other clip instances, too:
+
+```ruby
+music = Chaussettes::Clip.new do |c|
+  c.in 'music-track.mp3'
+  c.out(device: :stdout).type(:wav)
+  c.chain.fade(0, 10, 0.5)
+end
+
+clip = Chaussettes::Clip.new do |c|
+  c.mix
+  c.in(music).volume(0.5).type(:wav)
+  c.in 'narration.wav'
+  c.out 'soundtrack.wav'
+end
+# sox --combine mix \
+#     --volume 0.5 --type wav "|sox music-track.mp3 --type wav - fade 0 10 0.5" \
+#     narration.wav soundtrack.wav
+```
+
+## Author
+
+Jamis Buck <jamis@jamisbuck.org>

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/examples/drum.rb

@@ -0,0 +1,22 @@
+require 'chaussettes'
+
+RHYTHM = [ 2, 1, 1, 2, 1, 0.5, 0.5, 2, 1, 1, 2, 1, 0.5, 0.5, 2 ].freeze
+BEAT = 0.25
+
+Chaussettes::Clip.new do |clip|
+  clip.show_progress(false)
+  clip.in(device: nil)
+
+  RHYTHM.each do |dur|
+    chain = clip.chain
+    chain.synth(BEAT * dur, :pluck) do |t|
+      t.start_tone nil, p1: 0.1
+    end
+    chain.synth(BEAT * dur, :noise) do |t|
+      t.combine :fmod
+    end
+  end
+
+  puts clip.command('play')
+  clip.play
+end

data/examples/ducking.rb

@@ -0,0 +1,65 @@
+# ruby ducking.rb track1 track2 output delay
+#
+# Mixes two tracks by reducing the volume of the first during the duration
+# of the second. The second track begins after delay seconds. Saves the
+# result as output.
+
+require 'chaussettes'
+
+track1 = ARGV[0] || abort("what's the first track?")
+track2 = ARGV[1] || abort("what's the second track?")
+delay  = ARGV[2] || abort("what's the delay in seconds?")
+output = ARGV[3] || abort("what's the output filename?")
+
+info1 = Chaussettes::Info.new(track1)
+info2 = Chaussettes::Info.new(track2)
+delay = delay.to_f
+
+if info1.duration < info2.duration + delay
+  abort 'first track is shorter than the second track!'
+end
+
+intro = Chaussettes::Clip.new do |clip|
+  clip.in(track1)
+  clip.out(device: :stdout).type(:wav)
+  clip.chain.fade(0, delay + 0.2, 0.4, type: :linear)
+end
+
+middle = Chaussettes::Clip.new do |clip|
+  clip.in(track1)
+  clip.out(device: :stdout).type(:wav)
+  clip.chain.
+    trim(delay, info2.duration).
+    vol(0.25).
+    pad(delay)
+end
+
+last = Chaussettes::Clip.new do |clip|
+  clip.in(track1)
+  clip.out(device: :stdout).type(:wav)
+  clip.chain.
+    trim(delay + info2.duration - 0.2).
+    fade(0.4, type: :linear).
+    pad(delay + info2.duration - 0.2)
+end
+
+overlay = Chaussettes::Clip.new do |clip|
+  clip.in(track2)
+  clip.out(device: :stdout).type(:wav)
+  clip.chain.pad(delay)
+end
+
+Chaussettes::Clip.new do |clip|
+  clip.mix
+
+  clip.in(intro).type(:wav)
+  clip.in(middle).type(:wav)
+  clip.in(last).type(:wav)
+  clip.in(overlay).type(:wav)
+
+  clip.out(output)
+  # ramp up the volume x4 to compensate for 4 clips being merged together
+  clip.chain.vol 4
+
+  clip.run
+end

data/examples/synth.rb

@@ -0,0 +1,22 @@
+require 'chaussettes'
+
+Chaussettes::Clip.new do |clip|
+  clip.show_progress false
+  clip.in(device: nil)
+
+  notes = %w(C3 E3 G3 C4)
+  20.times do
+    clip.chain.synth(0.2, :pluck) do |t|
+      t.start_tone notes.sample, bias: 0, shift: rand(100), p1: 2
+    end.synth(0.2, :pluck) do |t|
+      t.combine :mix
+      t.start_tone notes.sample, bias: 0, shift: rand(100), p1: 2
+    end
+  end
+
+  # show the command that will be run
+  puts clip.command('play')
+
+  # play it!
+  clip.play
+end

data/lib/chaussettes.rb

@@ -0,0 +1,2 @@
+require 'chaussettes/clip'
+require 'chaussettes/info'

data/lib/chaussettes/clip.rb

@@ -0,0 +1,119 @@
+require 'chaussettes/input'
+require 'chaussettes/output'
+require 'chaussettes/effect_chain'
+require 'chaussettes/tool'
+
+module Chaussettes
+
+  # encapsulates an invocation of sox
+  class Clip
+    def initialize
+      @combine = nil
+      @globals = []
+      @inputs = []
+      @output = nil
+      @effect_chains = []
+
+      yield self if block_given?
+    end
+
+    def command(cmd = 'sox')
+      raise 'a clip requires at least one input' if @inputs.empty?
+      Tool.new(cmd).tap { |sox| _build_command(sox) }
+    end
+
+    def run
+      system(command.to_s)
+      self
+    end
+
+    def play
+      system(command('play').to_s)
+      self
+    end
+
+    def _build_command(sox)
+      sox << '--combine' << @combine if @combine
+      _append_globals sox
+      _append_inputs sox
+      _append_output sox
+      _append_effects sox
+    end
+
+    def _append_globals(sox)
+      @globals.each { |global| sox << global }
+    end
+
+    def _append_inputs(sox)
+      @inputs.each { |input| sox.concat(input.commands) }
+    end
+
+    def _append_output(sox)
+      sox.concat(@output.commands) if @output
+    end
+
+    def _append_effects(sox)
+      @effect_chains.each.with_index do |chain, idx|
+        sox << ':' if idx > 0
+        sox.concat(chain.commands)
+      end
+    end
+
+    def combine(method)
+      @combine = method
+      self
+    end
+
+    def guard
+      @globals << '--guard'
+      self
+    end
+
+    def merge
+      @combine = :merge
+      self
+    end
+
+    def mix
+      @combine = :mix
+      self
+    end
+
+    def multiply
+      @combine = :multiply
+      self
+    end
+
+    def show_progress(flag)
+      @globals << (flag ? '--show-progress' : '--no-show-progress')
+      self
+    end
+
+    def repeatable
+      @globals << '-R'
+      self
+    end
+
+    def verbose(level)
+      @globals << "-V#{level}"
+      self
+    end
+
+    def in(source = nil, device: nil)
+      Input.new(source, device: device).tap do |input|
+        @inputs << input
+      end
+    end
+
+    def out(dest = nil, device: nil)
+      @output = Output.new(dest, device: device)
+    end
+
+    def chain
+      EffectChain.new.tap do |chain|
+        @effect_chains << chain
+      end
+    end
+  end
+
+end

data/lib/chaussettes/common_options.rb

@@ -0,0 +1,46 @@
+module Chaussettes
+
+  # options that are common between input and output files
+  module CommonOptions
+    def bits(bits)
+      @arguments << '--bits' << bits
+      self
+    end
+
+    def channels(channels)
+      @arguments << '--channels' << channels
+      self
+    end
+
+    def encoding(encoding)
+      @arguments << '--encoding' << encoding
+      self
+    end
+
+    def rate(rate)
+      @arguments << '--rate' << rate
+      self
+    end
+
+    def type(type)
+      @arguments << '--type' << type
+      self
+    end
+
+    def endian(option)
+      @arguments << '--endian' << option
+      self
+    end
+
+    def reverse_nibbles
+      @arguments << '--reverse-nibbles'
+      self
+    end
+
+    def reverse_bits
+      @arguments << '--reverse-bits'
+      self
+    end
+  end
+
+end

data/lib/chaussettes/effect/fade.rb

@@ -0,0 +1,31 @@
+module Chaussettes
+  module Effect
+
+    # Represents a fade effect
+    class Fade
+      TYPE_MAP = {
+        nil => nil,
+        :h => 'h', 'h' => 'h', :half_sine => 'h',
+        :l => 'l', 'l' => 'l', :log => 'l', :logarithmic => 'l',
+        :p => 'p', 'p' => 'p', :parabola => 'p', :inverted_parabola => 'p',
+        :q => 'q', 'q' => 'q', :quarter => 'q',
+        :t => 't', 't' => 't', :linear => 't', :triangle => 't'
+      }.freeze
+
+      attr_reader :commands
+
+      def initialize(in_len, stop_at = nil, out_len = nil, type: nil)
+        real_type = TYPE_MAP.fetch(type)
+
+        @commands = [ 'fade' ]
+        @commands << real_type if real_type
+        @commands << in_len
+        @commands << stop_at if stop_at
+        @commands << out_len if stop_at && out_len
+
+        @commands.freeze
+      end
+    end
+
+  end
+end

data/lib/chaussettes/effect/gain.rb

@@ -0,0 +1,27 @@
+module Chaussettes
+  module Effect
+
+    # Represents a gain effect
+    class Gain
+      TYPE_MAP = {
+        :e => 'e', 'e' => 'e', :equalize => 'e',
+        :B => 'B', 'B' => 'B', :balance => 'B',
+        :b => 'b', 'b' => 'b', :balance_protect => 'b',
+        :r => 'r', 'r' => 'r', :reclaim_headroom => 'r',
+        :n => 'n', 'n' => 'n', :normalize => 'n',
+        :l => 'l', 'l' => 'l', :limiter => 'l',
+        :h => 'h', 'h' => 'h', :headroom => 'h'
+      }.freeze
+
+      attr_reader :commands
+
+      def initialize(db, *opts)
+        @commands = [ 'gain' ]
+        @commands.concat(opts.map { |opt| TYPE_MAP.fetch(opt) })
+        @commands << db
+        @commands.freeze
+      end
+    end
+
+  end
+end

data/lib/chaussettes/effect/synth.rb

@@ -0,0 +1,130 @@
+module Chaussettes
+  module Effect
+
+    # Represents a synth effect
+    class Synth
+      attr_reader :commands
+
+      def initialize(length = nil, type = nil)
+        @length = length
+        @type = type
+
+        @just_intonation = nil
+        @combine = nil
+        @start_tone = nil
+        @end_tone = nil
+        @headroom = true
+
+        yield self if block_given?
+
+        _build_commands
+      end
+
+      def _build_commands
+        @commands = [ 'synth' ]
+        @commands << '-j' << @just_intonation if @just_intonation
+        @commands << '-n' unless @headroom
+
+        _append_start_params
+
+        @commands << @type if @type
+        @commands << @combine if @combine
+
+        _append_tones
+
+        @commands.freeze
+      end
+
+      def _append_start_params
+        return unless @length
+        @commands << @length
+        _append_opts @start_opts
+      end
+
+      OPT_NAMES = %i(bias shift p1 p2 p3).freeze
+      DEFAULTS = { bias: 0, shift: 0 }.freeze
+
+      def _append_opts(opts)
+        return unless opts && opts.any?
+
+        OPT_NAMES.each do |opt|
+          value = opts[opt] || DEFAULTS[opt]
+          break unless value
+          @commands << value
+        end
+      end
+
+      def _append_tones
+        return unless @start_tone
+
+        tone = if @end_tone
+                 "#{@start_tone}#{@sweep}#{@end_tone}"
+               else
+                 @start_tone
+               end
+
+        @commands << tone
+
+        _append_opts @end_opts
+      end
+
+      def headroom(enabled)
+        @headroom = enabled
+        self
+      end
+
+      def just_intonation(semitones)
+        @just_intonation = semitones
+        self
+      end
+
+      def combine(method)
+        @combine = method
+        self
+      end
+
+      def length(len)
+        @length = len
+        self
+      end
+
+      def type(type)
+        @type = type
+        self
+      end
+
+      # options are:
+      #   bias:
+      #   shift:
+      #   p1:
+      #   p2:
+      #   p3:
+      def start_tone(start_tone, opts = {})
+        @start_tone = start_tone
+        @start_opts = opts
+        self
+      end
+
+      # options are:
+      #   bias:
+      #   shift:
+      #   p1:
+      #   p2:
+      #   p3:
+      def end_tone(end_tone, sweep = :linear, opts = {})
+        @end_tone = end_tone
+        @sweep = SWEEPS.fetch(sweep, sweep)
+        @end_opts = opts
+        self
+      end
+
+      SWEEPS = {
+        linear: ':',
+        square: '+',
+        exponential: '/', exp: '/',
+        exp2: '-'
+      }.freeze
+    end
+
+  end
+end

data/lib/chaussettes/effect/vol.rb

@@ -0,0 +1,18 @@
+module Chaussettes
+  module Effect
+
+    # Represents a volume effect
+    class Vol
+      attr_reader :commands
+
+      def initialize(gain, type: nil, limitergain: nil)
+        @commands = [ 'vol' ]
+        @commands << gain
+        @commands << type if type
+        @commands << limitergain if type && limitergain
+        @commands.freeze
+      end
+    end
+
+  end
+end

data/lib/chaussettes/effect_chain.rb

@@ -0,0 +1,67 @@
+require 'chaussettes/effect/fade'
+require 'chaussettes/effect/gain'
+require 'chaussettes/effect/synth'
+require 'chaussettes/effect/vol'
+
+module Chaussettes
+
+  # A chain of effects to apply
+  class EffectChain
+    attr_reader :commands
+
+    def initialize
+      @commands = []
+    end
+
+    def fade(in_len, stop_at = nil, out_len = nil, type: nil)
+      effect = Effect::Fade.new(in_len, stop_at, out_len, type: type)
+      @commands.concat(effect.commands)
+      self
+    end
+
+    def gain(db, *opts)
+      effect = Effect::Gain.new(db, *opts)
+      @commands.concat(effect.commands)
+      self
+    end
+
+    def newfile
+      @commands << 'newfile'
+      self
+    end
+
+    def pad(length, position = nil)
+      length = "#{length}@#{position}" if position
+      @commands << 'pad' << length
+      self
+    end
+
+    def restart
+      @commands << 'restart'
+      self
+    end
+
+    def synth(length = nil, type = nil, &block)
+      effect = Effect::Synth.new(length, type, &block)
+      @commands.concat(effect.commands)
+      self
+    end
+
+    def trim(*positions)
+      if positions.empty?
+        raise ArgumentError, 'you must specify at least one position for trim'
+      end
+
+      @commands << 'trim'
+      @commands.concat(positions)
+      self
+    end
+
+    def vol(gain, type: nil, limitergain: nil)
+      effect = Effect::Vol.new(gain, type: type, limitergain: limitergain)
+      @commands.concat(effect.commands)
+      self
+    end
+  end
+
+end

data/lib/chaussettes/info.rb

@@ -0,0 +1,57 @@
+require 'chaussettes/tool'
+
+module Chaussettes
+
+  # encapsulates info about an audio file
+  class Info
+    def initialize(filename)
+      command = Tool.new('soxi') << filename
+      output = `#{command}`
+      @data = _parse(output)
+    end
+
+    def _parse(output)
+      output.lines.each.with_object({}) do |line, hash|
+        next if line.strip.empty?
+        key, value = line.split(/:/, 2)
+        hash[key.strip] = value.strip
+      end
+    end
+
+    def filename
+      @_filename ||= @data['Input File']
+    end
+
+    def channels
+      @_channels ||= @data['Channels'].to_i
+    end
+
+    def rate
+      @_rate ||= @data['Sample Rate'].to_i
+    end
+
+    def bits
+      @_bits ||= @data['Precision'].to_i
+    end
+
+    def duration
+      @_duration ||= begin
+        timespec = @data['Duration'].split(/ /).first
+        h, m, s = timespec.split(/:/)
+
+        h.to_i * 3600 +
+          m.to_i * 60 +
+          s.to_f
+      end
+    end
+
+    def size
+      @_size ||= @data['File Size']
+    end
+
+    def bit_rate
+      @_bit_rate ||= @data['Bit Rate']
+    end
+  end
+
+end

data/lib/chaussettes/input.rb

@@ -0,0 +1,50 @@
+require 'chaussettes/common_options'
+
+module Chaussettes
+
+  # Represents an input to an operation
+  class Input
+    include CommonOptions
+
+    def initialize(source = nil, device: nil)
+      @source = _translate_source(source) ||
+                _translate_device(device) ||
+                raise(ArgumentError, 'unsupported source')
+
+      @arguments = []
+    end
+
+    def _translate_source(source)
+      if source.is_a?(String)
+        source
+      elsif source.respond_to?(:command)
+        "|#{source.command}"
+      end
+    end
+
+    def _translate_device(device)
+      if device == :default
+        '--default-device'
+      elsif device == :stdin
+        '-'
+      elsif device.nil? || device == :null
+        '--null'
+      end
+    end
+
+    def commands
+      [ *@arguments, @source ]
+    end
+
+    def ignore_length
+      @arguments << '--ignore-length'
+      self
+    end
+
+    def volume(factor)
+      @arguments << '--volume' << factor
+      self
+    end
+  end
+
+end

data/lib/chaussettes/output.rb

@@ -0,0 +1,53 @@
+require 'chaussettes/common_options'
+
+module Chaussettes
+
+  # Represents the output of an operation
+  class Output
+    include CommonOptions
+
+    def initialize(dest = nil, device: nil)
+      @dest = _translate_dest(dest) ||
+              _translate_device(device) ||
+              raise(ArgumentError, 'unsupported dest/device')
+
+      @arguments = []
+    end
+
+    def _translate_dest(dest)
+      dest ? dest.to_s : nil
+    end
+
+    def _translate_device(device)
+      if device == :pipe
+        '--sox-pipe'
+      elsif device == :default
+        '--default-device'
+      elsif device.nil? || device == :null
+        '--null'
+      elsif device == :stdout
+        '-'
+      end
+    end
+
+    def commands
+      [ *@arguments, @dest ]
+    end
+
+    def add_comment(text)
+      @arguments << '--add-comment' << text
+      self
+    end
+
+    def comment(text)
+      @arguments << '--comment' << text
+      self
+    end
+
+    def compression(factor)
+      @arguments << '--compression' << factor
+      self
+    end
+  end
+
+end

data/lib/chaussettes/tool.rb

@@ -0,0 +1,27 @@
+require 'shellwords'
+
+module Chaussettes
+
+  # a generic wrapper for sox audio toolchain
+  class Tool
+    def initialize(command)
+      @command = command
+      @arguments = []
+    end
+
+    def <<(arg)
+      @arguments << arg
+      self
+    end
+
+    def concat(args)
+      @arguments.concat(args)
+      self
+    end
+
+    def to_s
+      Shellwords.join([ @command, *@arguments ])
+    end
+  end
+
+end

data/lib/chaussettes/version.rb

@@ -0,0 +1,3 @@
+module Chaussettes
+  VERSION = '1.0.0'.freeze
+end

data/test/chaussettes/clip_test.rb

@@ -0,0 +1,78 @@
+require 'minitest/autorun'
+require 'chaussettes/clip'
+
+class ClipTest < Minitest::Test
+  def setup
+    @clip = Chaussettes::Clip.new
+  end
+
+  def test_merge_becomes_combine_option
+    @clip.merge
+    @clip.in
+    @clip.out
+
+    assert_equal 'sox --combine merge --null --null', @clip.command.to_s
+  end
+
+  def test_mix_becomes_combine_option
+    @clip.mix
+    @clip.in
+    @clip.out
+
+    assert_equal 'sox --combine mix --null --null', @clip.command.to_s
+  end
+
+  def test_multiply_becomes_combine_option
+    @clip.multiply
+    @clip.in
+    @clip.out
+
+    assert_equal 'sox --combine multiply --null --null', @clip.command.to_s
+  end
+
+  def test_combine_option
+    @clip.in
+    @clip.out
+    @clip.combine :concatenate
+
+    assert_equal 'sox --combine concatenate --null --null', @clip.command.to_s
+  end
+
+  def test_global_options
+    @clip.guard.repeatable.verbose(2)
+    @clip.in
+    @clip.out
+
+    assert_equal 'sox --guard -R -V2 --null --null', @clip.command.to_s
+  end
+
+  def test_multiple_inputs_are_rendered
+    @clip.in('file1.wav')
+    @clip.in('file2.wav')
+    @clip.out
+    assert_equal 'sox file1.wav file2.wav --null', @clip.command.to_s
+  end
+
+  def test_output_is_rendered
+    @clip.in
+    @clip.out('out.wav')
+    assert_equal 'sox --null out.wav', @clip.command.to_s
+  end
+
+  def test_chain_adds_effect_chain
+    @clip.in
+    @clip.out
+    @clip.chain.trim(0, 10).pad(1.5)
+    assert_equal 'sox --null --null trim 0 10 pad 1.5', @clip.command.to_s
+  end
+
+  def test_multiply_effect_chains
+    @clip.in
+    @clip.out
+    @clip.chain.trim(0, 10).pad(1.5)
+    @clip.chain.newfile
+    @clip.chain.restart
+    assert_equal 'sox --null --null trim 0 10 pad 1.5 : newfile : restart',
+                 @clip.command.to_s
+  end
+end

data/test/chaussettes/input_test.rb

@@ -0,0 +1,61 @@
+require 'minitest/autorun'
+require 'ostruct'
+require 'chaussettes/input'
+
+class InputTest < Minitest::Test
+  def test_init_with_string_should_use_string_as_source
+    input = Chaussettes::Input.new('input.wav')
+    assert_equal [ 'input.wav' ], input.commands
+  end
+
+  def test_init_with_command_should_use_command_as_source
+    command = OpenStruct.new(command: 'cmd -x -y -z')
+    input = Chaussettes::Input.new(command)
+    assert_equal [ '|cmd -x -y -z' ], input.commands
+  end
+
+  def test_init_with_no_arguments_should_use_null_input
+    input = Chaussettes::Input.new
+    assert_equal [ '--null' ], input.commands
+  end
+
+  def test_init_with_nil_device_should_use_null_input
+    input = Chaussettes::Input.new(device: nil)
+    assert_equal [ '--null' ], input.commands
+  end
+
+  def test_init_with_null_device_should_use_null_input
+    input = Chaussettes::Input.new(device: :null)
+    assert_equal [ '--null' ], input.commands
+  end
+
+  def test_init_with_stdin_device_should_use_dash_input
+    input = Chaussettes::Input.new(device: :stdin)
+    assert_equal [ '-' ], input.commands
+  end
+
+  def test_init_with_default_device_should_use_default_device
+    input = Chaussettes::Input.new(device: :default)
+    assert_equal [ '--default-device' ], input.commands
+  end
+
+  def test_arguments_should_precede_input_source
+    input = Chaussettes::Input.new('hello.mp3').ignore_length.volume(0.5)
+    expect = [ '--ignore-length', '--volume', 0.5, 'hello.mp3' ]
+    assert_equal expect, input.commands
+  end
+
+  def test_common_options_should_be_included
+    input = Chaussettes::Input.new('hello.mp3').
+            bits(8).channels(2).encoding('encoding').rate(44_100).type('mp3').
+            endian('little').reverse_nibbles.reverse_bits
+
+    expected = [
+      '--bits', 8, '--channels', 2, '--encoding', 'encoding', '--rate', 44_100,
+      '--type', 'mp3', '--endian', 'little', '--reverse-nibbles',
+      '--reverse-bits', 'hello.mp3'
+    ]
+
+    assert_equal expected, input.commands
+  end
+end

data/test/chaussettes/output_test.rb

@@ -0,0 +1,61 @@
+require 'minitest/autorun'
+require 'chaussettes/output'
+
+class OutputTest < Minitest::Test
+  def test_init_with_string_should_use_string_as_dest
+    output = Chaussettes::Output.new('output.wav')
+    assert_equal [ 'output.wav' ], output.commands
+  end
+
+  def test_init_with_no_arguments_should_use_null_output
+    output = Chaussettes::Output.new
+    assert_equal [ '--null' ], output.commands
+  end
+
+  def test_init_with_nil_device_should_use_null_output
+    output = Chaussettes::Output.new(device: nil)
+    assert_equal [ '--null' ], output.commands
+  end
+
+  def test_init_with_null_device_should_use_null_output
+    output = Chaussettes::Output.new(device: :null)
+    assert_equal [ '--null' ], output.commands
+  end
+
+  def test_init_with_stdout_device_should_use_dash_output
+    output = Chaussettes::Output.new(device: :stdout)
+    assert_equal [ '-' ], output.commands
+  end
+
+  def test_init_with_pipe_device_should_use_sox_pipe_output
+    output = Chaussettes::Output.new(device: :pipe)
+    assert_equal [ '--sox-pipe' ], output.commands
+  end
+
+  def test_init_with_default_device_should_use_default_device
+    output = Chaussettes::Output.new(device: :default)
+    assert_equal [ '--default-device' ], output.commands
+  end
+
+  def test_arguments_should_precede_output_dest
+    output = Chaussettes::Output.new('hello.mp3').
+             comment('cmt').add_comment('cmt2').compression(2)
+    expect = [ '--comment', 'cmt', '--add-comment', 'cmt2', '--compression', 2,
+               'hello.mp3' ]
+    assert_equal expect, output.commands
+  end
+
+  def test_common_options_should_be_included
+    output = Chaussettes::Output.new('hello.mp3').
+             bits(8).channels(2).encoding('encoding').rate(44_100).type('mp3').
+             endian('little').reverse_nibbles.reverse_bits
+
+    expected = [
+      '--bits', 8, '--channels', 2, '--encoding', 'encoding', '--rate', 44_100,
+      '--type', 'mp3', '--endian', 'little', '--reverse-nibbles',
+      '--reverse-bits', 'hello.mp3'
+    ]
+
+    assert_equal expected, output.commands
+  end
+end

data/test/chaussettes/tool_test.rb

@@ -0,0 +1,27 @@
+require 'minitest/autorun'
+require 'chaussettes/tool'
+
+class ToolTest < Minitest::Test
+  def setup
+    @tool = Chaussettes::Tool.new('command')
+  end
+
+  def test_empty_arguments_should_render_only_the_command
+    assert_equal 'command', @tool.to_s
+  end
+
+  def test_appended_arguments_should_be_rendered
+    @tool << '-flag' << 'value'
+    assert_equal 'command -flag value', @tool.to_s
+  end
+
+  def test_concatted_arguments_should_be_rendered
+    @tool.concat [ '-flag', 'value' ]
+    assert_equal 'command -flag value', @tool.to_s
+  end
+
+  def test_special_chars_should_be_escaped
+    @tool << '-flag' << 'two words' << 'angry!'
+    assert_equal 'command -flag two\ words angry\!', @tool.to_s
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: chaussettes
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jamis Buck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A wrapper around the sox audio manipulation utility
+email:
+- jamis@jamisbuck.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- examples/drum.rb
+- examples/ducking.rb
+- examples/synth.rb
+- lib/chaussettes.rb
+- lib/chaussettes/clip.rb
+- lib/chaussettes/common_options.rb
+- lib/chaussettes/effect/fade.rb
+- lib/chaussettes/effect/gain.rb
+- lib/chaussettes/effect/synth.rb
+- lib/chaussettes/effect/vol.rb
+- lib/chaussettes/effect_chain.rb
+- lib/chaussettes/info.rb
+- lib/chaussettes/input.rb
+- lib/chaussettes/output.rb
+- lib/chaussettes/tool.rb
+- lib/chaussettes/version.rb
+- test/chaussettes/clip_test.rb
+- test/chaussettes/input_test.rb
+- test/chaussettes/output_test.rb
+- test/chaussettes/tool_test.rb
+homepage: http://github.com/jamis/chaussettes
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A wrapper around the sox audio manipulation utility
+test_files:
+- test/chaussettes/clip_test.rb
+- test/chaussettes/input_test.rb
+- test/chaussettes/output_test.rb
+- test/chaussettes/tool_test.rb