ruby-sox 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b3d0a858629f10877dee7bc1be0f707777f3215d
+  data.tar.gz: bae090b2b7124e2a37f15b1c9001bfa6ed79fced
+SHA512:
+  metadata.gz: a532d4ab550278235dc139d9aa297f7494ba49b06d051a0c1e4e709cfbf78e837915f8f128b5482d6f6bbc83425020095b217f50fec6dcaf2e372c41692192e5
+  data.tar.gz: c428ddd99eb71e1b157d79b10c301f7a2dd320e4ed8fe332e924d0ec5e19cd6744c13ecec1142b9dd703e5cfd291d82433d01b057ba2f4f22f9f03f4c9d69bcf

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2013 TMX Credit, author Potapov Sergey
+
+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.
+
+The audio files are distributed under Creative Commons Attribution 3.0
+Unported License.

data/README.markdown

@@ -0,0 +1,114 @@
+# Ruby SoX
+
+[![Build Status](https://travis-ci.org/TMXCredit/ruby-sox.png?branch=master)](https://travis-ci.org/TMXCredit/ruby-sox)
+
+A Ruby wrapper for the `sox` command line tool to process sound.
+
+
+## Dependencies
+
+* SoX
+* Bash (for process substitution combiner strategy)
+* Chromaprint (only to run tests)
+
+### Debian / Ubuntu
+
+```bash
+apt-get install libsox-fmt-all sox libchromaprint-dev
+```
+
+### Mac
+
+```bash
+# One of the following
+# Notes:
+# * chromaprint is not available in MacPorts as of this writing
+# * flac must be installed before sox so it will link during compilation
+sudo port install flac sox && brew install chromaprint
+brew install flac sox chromaprint
+```
+
+# Usage
+
+Remember that it's a wrapper for `sox` to provide Ruby API.
+It's assumed that you know the basics of sound computing theory and how
+the `sox` tool works. Otherwise, `man sox` is your good friend.
+
+## Sox::Cmd
+
+Allows you to do everything that the `sox` command does.
+
+Mix 3 files into one (ruby-sox assumes that input files have same rate and number of channels):
+
+```ruby
+# Build command
+sox = Sox::Cmd.new(:combine => :mix)
+        .add_input("guitar1.flac")
+        .add_input("guitar2.flac")
+        .add_input("drums.flac")
+        .set_output("hell_rock-n-roll.mp3")
+        .set_effects(:rate => 44100, :channels => 2)
+
+# Execute command
+sox.run
+```
+
+## Sox::Combiner
+
+Sox::Combiner combines files even if they have different rates or numbers
+of channels. Under the hood, it converts the input files into temporary files
+to have the same rate and number of channels, and then combines them.
+
+Concatenate:
+
+```ruby
+combiner = Sox::Combiner.new('in1.mp3', 'in2.ogg', 'in3.wav', :combine => :concatenate)
+combiner.write('out.mp3')
+```
+
+Mix 3 files into an MP3 with 2 channels and a rate of 1600:
+
+```ruby
+combiner = Sox::Combiner.new('in1.mp3', 'in2.ogg', 'in3.wav', :combine => :mix, :rate => 1600, :channels => 2)
+combiner.write('out.mp3')
+```
+
+## Run specs
+
+```bash
+rake spec
+```
+
+## Credits
+
+* [Sergey Potapov](https://github.com/greyblake)
+
+## License
+
+Copyright (c) 2013 TMX Credit, author Potapov Sergey
+
+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.
+
+The audio files are distributed under [Creative Commons Attribution 3.0
+Unported License](http://creativecommons.org/licenses/by/3.0/legalcode).
+
+## Copyright
+
+Copyright (c) 2013 TMX Credit.

data/lib/ruby-sox.rb

@@ -0,0 +1,2 @@
+require File.expand_path('../sox', __FILE__)
+

data/lib/sox/cmd.rb

@@ -0,0 +1,85 @@
+module Sox
+  # Process audio files using the +sox+ shell command.
+  #
+  # @example
+  #   # Mix 3 files into one
+  #   sox = Sox::Cmd.new(:combine => :mix)
+  #   sox.add_input("guitar1.flac")
+  #   sox.add_input("guitar2.flac")
+  #   sox.add_input("drums.flac")
+  #   sox.set_output("hell_rock-n-roll.mp3")
+  #   sox.set_effects(:rate => 44100, :channels => 2)
+  #   sox.run
+  class Cmd
+    include Sox::Shell
+
+    attr_reader :options, :inputs, :output, :effects
+
+    # @param options [Hash] global options for sox command
+    def initialize(options = {})
+      @options = options
+      @inputs  = []
+      @effects = {}
+    end
+
+    # Add input file with its options.
+    #
+    # @param file_path [String] path to file
+    # @param input_options [Hash] options for input files, see +man sox+
+    #
+    # @return [Sox::Cmd] self
+    def add_input(file_path, input_options = {})
+      @inputs << Sox::File.new(file_path, input_options)
+      self
+    end
+
+    # Set output file and its options.
+    #
+    # @param file_path [String] ouput file path
+    # @param output_options [Hash] options for output file, see +man sox+
+    #
+    # @return [Sox::Cmd] self
+    def set_output(file_path, output_options = {})
+      @output = Sox::File.new(file_path, output_options)
+      self
+    end
+
+    # Set effects on the output file. See +man sox+ section +EFFECTS+.
+    # It receives the effect name as a hash key and the effect arguments as
+    # hash values which can be a string or an array of strings. If an effect
+    # has no arguments just pass +true+ as the value.
+    #
+    # @example
+    #   # Normalize and use 2 channels for output
+    #   sox_cmd.set_effects(:channels => 2, :norm => true)
+    #
+    # @param effects [Hash{Symbol, String => Symbol, String, Array<String>}]
+    #
+    # @return [Sox::Cmd] self
+    def set_effects(effects)
+      @effects = effects
+      self
+    end
+
+    # Set global options. See +man sox+ section +Global Options+.
+    #
+    # @param options [Hash] global options for +sox+ command
+    #
+    # @return [Sox::Cmd] self
+    def set_options(options)
+      @options = options
+      self
+    end
+
+    # Run `sox` command. Raise {Sox::Error} on fail.
+    #
+    # @return [Boolean] true in case of success
+    def run
+      raise(Sox::Error, "Output is missing, specify it with `set_output`")   unless @output
+      raise(Sox::Error, "Inputs are missing, specify them with `add_input`") if @inputs.empty?
+
+      cmd = CommandBuilder.new(@inputs, @output, @options, @effects).build
+      sh(cmd)
+    end
+  end
+end

data/lib/sox/combiner/base_strategy.rb

@@ -0,0 +1,37 @@
+module Sox
+  # Common parent class for combiner strategies.
+  class Combiner::BaseStrategy
+    include Sox::Shell
+
+    # @param input_files [Array<String>] input files
+    # @param options [Hash] see {Sox::Combiner#initialize}
+    def initialize(input_files, options)
+      @input_files = input_files
+      @options     = options
+    end
+
+    # Run the command, and save output in the output file.
+    #
+    # @param output_file [String]
+    #
+    # @return [void]
+    def write(output_file)
+      raise NotImplementedError, __method__
+    end
+
+
+    # Build effects which will be applied on final output.
+    #
+    # @return [Hash]
+    def output_effects
+      {:norm => @options[:norm]}
+    end
+
+    # Build global options for +sox+ command.
+    #
+    # @return [Hash]
+    def output_options
+      {:combine => @options[:combine]}
+    end
+  end
+end

data/lib/sox/combiner/process_substitution_strategy.rb

@@ -0,0 +1,78 @@
+module Sox
+  # Combines files using process substitution to build and use mediate files.
+  # Process substitution is not supported by the standard shell, so we need
+  # to pass the final command to bash via shell.
+  #
+  # Read more about process substitution:
+  # http://en.wikipedia.org/wiki/Process_substitution
+  class Combiner::ProcessSubstitutionStrategy < Combiner::BaseStrategy
+    # Type of mediate files:
+    MEDIATE_TYPE = :sox
+
+    # Number of bits for mediate files:
+    MEDIATE_BITS = 32
+
+    # Encoding of mediate files:
+    MEDIATE_ENCODING = :signed
+
+    # Pseudo file which makes the `sox` command write to output to stdout:
+    SOX_PIPE = '-p'
+
+    # :nodoc:
+    def write(output_file)
+      inputs = @input_files.map { |file| build_input_file(file) }
+      output = Sox::File.new(output_file)
+
+      cmd = CommandBuilder.new(inputs, output, output_options, output_effects).build
+      bash(cmd)
+    end
+
+
+    # Build the input file which can be used in the command builder to get
+    # the final output.
+    #
+    # @param file_path [String] path to input file
+    #
+    # @return [Sox::File]
+    def build_input_file(file_path)
+      Sox::File.new(build_converted_input(file_path),
+        :type     => MEDIATE_TYPE,
+        :encoding => MEDIATE_ENCODING,
+        :bits     => MEDIATE_BITS,
+        :channels => @options[:channels],
+        :rate     => @options[:rate]
+     ).tap { |file| file.escaped = true }
+    end
+    private :build_input_file
+
+    # Build the shell statement which can be used as the input file with
+    # the needed rate and number of channels.
+    #
+    # @param input_file [String]
+    #
+    # @return [String] shell statement which can be used as input file
+    #
+    # @example
+    #   build_converted_input("in.mp3")
+    #   # => "<(sox in.mp3 --encoding sox --bits 32 -p rate 22100 channels 1)"
+    def build_converted_input(input_file)
+      input    = Sox::File.new(input_file)
+      output   = Sox::File.new(SOX_PIPE, :encoding => MEDIATE_ENCODING, :bits => MEDIATE_BITS)
+      effects  = {:channels => @options[:channels], :rate => @options[:rate]}
+      command  = CommandBuilder.new([input], output, {}, effects).build
+      process_substitution_wrap(command)
+    end
+    private :build_converted_input
+
+    # Wrap shell command to make its output be used in process substitution.
+    # See http://en.wikipedia.org/wiki/Process_substitution for more info.
+    #
+    # @param command [String] shell command
+    #
+    # @return [String]
+    def process_substitution_wrap(command)
+      "<(#{command})"
+    end
+    private :process_substitution_wrap
+  end
+end

data/lib/sox/combiner/tmp_file_strategy.rb

@@ -0,0 +1,78 @@
+module Sox
+  # Combines files using temporary files as mediate files.
+  class Combiner::TmpFileStrategy < Combiner::BaseStrategy
+    # Type of temporary mediate files:
+    MEDIATE_TYPE = :raw
+
+    # Number of bits for temporary mediate files:
+    MEDIATE_BITS = 16
+
+    # Encoding of temporary mediate files:
+    MEDIATE_ENCODING = :signed
+
+
+    # :nodoc:
+    def write(output_file)
+      tmp_files = []
+
+      @input_files.each do |input_file|
+        tmp_output_file = gen_tmp_filename
+        tmp_files << tmp_output_file
+
+        cmd = build_convert_command(input_file, tmp_output_file)
+        sh(cmd)
+      end
+
+      cmd = build_output_command(tmp_files, output_file)
+      sh(cmd)
+    ensure
+      # Remove temporary files
+      tmp_files.each { |file| FileUtils.rm(file) if ::File.exists?(file) }
+    end
+
+    # Build +sox+ command to get final output.
+    #
+    # @param input_files [Array<String>]
+    # @param output_file [String]
+    #
+    # @return [String] sox command
+    def build_output_command(input_files, output_file)
+      inputs = input_files.map do |path|
+        Sox::File.new(path,
+          :type     => MEDIATE_TYPE,
+          :encoding => MEDIATE_ENCODING,
+          :bits     => MEDIATE_BITS,
+          :channels => @options[:channels],
+          :rate     => @options[:rate])
+      end
+
+      output = Sox::File.new(output_file)
+
+      builder = CommandBuilder.new(inputs, output, output_options, output_effects)
+      builder.build
+    end
+    private :build_output_command
+
+    # Build shell command which converts input file into temporary file with
+    # desired rate and channels.
+    #
+    # @param input_file [String] input file
+    # @param output_file [String] converted output with desired characteristics
+    #
+    # @return [String] shell command
+    def build_convert_command(input_file, output_file)
+      builder = CommandBuilder.new([Sox::File.new(input_file)], Sox::File.new(output_file))
+      builder.effects = {:channels => @options[:channels], :rate => @options[:rate]}
+      builder.build
+    end
+    private :build_convert_command
+
+    # Generate path to temporary file with unique name.
+    #
+    # @return [String] path to temporary file
+    def gen_tmp_filename
+      Dir::Tmpname.make_tmpname ['/tmp/ruby-sox', ".#{MEDIATE_TYPE}"], nil
+    end
+    private :gen_tmp_filename
+  end
+end

data/lib/sox/combiner.rb

@@ -0,0 +1,73 @@
+module Sox
+  # Combines input files. Technically it calls +sox+ with +--combine+ option,
+  # but allows you not to care about the rates and numbers of channels in the
+  # input files. It converts them to the same rates/channels using temporary
+  # mediate files.
+  #
+  # @example
+  #   # Concatenate
+  #   combiner = Sox::Combiner.new('in1.mp3', 'in2.ogg', 'in3.wav', :combine => :concatenate)
+  #   combiner.write('out.mp3')
+  class Combiner
+
+    autoload :BaseStrategy               , 'sox/combiner/base_strategy'
+    autoload :TmpFileStrategy            , 'sox/combiner/tmp_file_strategy'
+    autoload :ProcessSubstitutionStrategy, 'sox/combiner/process_substitution_strategy'
+
+    # Default options
+    DEFAULT_OPTIONS = {
+      # Method to be used for combining sounds. See --combine of sox tool.
+      :combine => :concatenate,
+
+      # Number of channels in the output file.
+      :channels => 1,
+
+      # Rate(samples per seconds) of the output file.
+      :rate => 22050,
+
+      # Apply norm effect on output.
+      :norm => false,
+
+      # Strategy to convert input files into files with the same rates
+      # and channels.
+      :strategy => :process_substitution
+    }
+
+    # Mapping of strategy names and their implementations
+    STRATEGIES = {
+      :tmp_file             => TmpFileStrategy,
+      :process_substitution => ProcessSubstitutionStrategy
+    }
+
+
+    # @param input_files [Array<String>] input files
+    # @param options [Hash]
+    #
+    # @option options :combine [Symbol] value for +--combine+ sox option.
+    #   Use underscore instead of hyphen, e.g. :mix_power.
+    # @option options :channels [Integer] number of channels in output file.
+    # @option options :rate [Integer] rate of output file
+    # @option options :norm [Boolean] apply +norm+ effect on output.
+    # @option options :strategy [Symbol] strategy to treat temporary files,
+    #   default is :process_substitution which reduces disk IO.
+    def initialize(input_files, options = {})
+      raise(ArgumentError, "Input files are missing") if input_files.empty?
+
+      opts           = DEFAULT_OPTIONS.merge(options)
+      strategy_name  = opts.delete(:strategy)
+      strategy_class = STRATEGIES[strategy_name]
+      raise(ArgumentError, "Unknown strategy #{strategy_name.inspect}") unless strategy_class
+
+      @strategy      = strategy_class.new(input_files, opts)
+    end
+
+    # Run +sox+ command and write output to file.
+    #
+    # @param output_file [String] path of output file
+    #
+    # @return [void]
+    def write(output_file)
+      @strategy.write(output_file)
+    end
+  end
+end

data/lib/sox/command_builder.rb

@@ -0,0 +1,98 @@
+module Sox
+  # Builds the +sox+ shell command from input files, an output file, options
+  # and effects.
+  #
+  # @example
+  #   builder = Sox::CommandBuilder.new(['in1.mp3', 'in2.ogg'], 'out.wav',
+  #     {:combine => :mix},
+  #     {:rate => 44100, :channels => 2}
+  #   )
+  #   builder.build  # => "sox --combine mix in1.mp3 in2.ogg out.wav rate 44100 channels 2"
+  class CommandBuilder
+    attr_accessor :input_files, :output_file, :options, :effects
+
+    # @param input_files [Array<Sox::File>]
+    # @param output_file [Sox::File]
+    # @param options [Hash{Symbol => Symbol}]
+    # @param effects [Hash{Symbol => Symbol}]
+    def initialize(input_files, output_file, options = {}, effects = {})
+      @input_files = input_files
+      @output_file = output_file
+      @options     = options
+      @effects     = effects
+    end
+
+    # Build shell command with all arguments and options.
+    #
+    # @return [String]
+    def build
+      [ Sox::SOX_COMMAND,
+        build_options(@options),
+        build_input_files,
+        build_file(@output_file),
+        build_effects
+      ].flatten.join(' ')
+    end
+
+
+    # Build input files with their options.
+    #
+    # @return [Array<String>]
+    def build_input_files
+      @input_files.map { |file| build_file(file) }
+    end
+    private :build_input_files
+
+    # Build part of SoX command which represents file(input or output).
+    #
+    # @param file [Sox::File] file
+    #
+    # @return [String]
+    def build_file(file)
+      opts = build_options(file.options)
+      file_path = file.escaped? ? file.path : Shellwords.escape(file.path)
+      [opts, file_path]
+    end
+    private :build_file
+
+    # Build options with their values (if present) to be used in shell command.
+    #
+    # @param options [Hash] options
+    #
+    # @return [Array<String>] options to be concatenated into string
+    def build_options(options)
+      options.inject([]) do |result, (opt, val)|
+        if val
+          result << "--#{shellify_opt(opt)}"
+          result << shellify_opt(val) if val != true
+        end
+        result
+      end
+    end
+    private :build_options
+
+    # Build effects with their arguments (if present) to be used in shell command.
+    #
+    # @return [Array<String>] effects to be concatenated into string
+    def build_effects
+      @effects.inject([]) do |result, (effect, val)|
+        if val
+          result << effect
+          result << val.to_s if val != true
+        end
+        result
+      end
+    end
+    private :build_effects
+
+    # Convert option or its value to shell style, separating words with "-".
+    #
+    # @param value [Symbol, String] option or value
+    #
+    # @return [String] shellified option
+    def shellify_opt(value)
+      value.to_s.gsub('_', '-')
+    end
+    private :shellify_opt
+  end
+end

data/lib/sox/file.rb

@@ -0,0 +1,29 @@
+module Sox
+  # Represents input or output file with its options for the `sox` command.
+  class File
+    # Path to file or whatever.
+    attr_reader :path
+
+    # File options which will be placed right before it.
+    attr_reader :options
+
+    # True if path doesn't need to be escaped.
+    attr_accessor :escaped
+
+
+    # @param path [String] path to file
+    # @param options [Hash{Symbol => Symbol,String,Numeric}] file options
+    def initialize(path, options = {})
+      @path    = path
+      @options = options
+      @escaped = false
+    end
+
+    # Does the path need to be escaped?
+    #
+    # @return [Boolean]
+    def escaped?
+      @escaped
+    end
+  end
+end

data/lib/sox/shell.rb

@@ -0,0 +1,45 @@
+module Sox
+  # Provides methods to run the command in the +/bin/sh+ and +/bin/bash+
+  # interpreters. Ruby's `system` method runs +/bin/sh+ which doesn't support
+  # the process substitution feature. So sometimes we need to use bash with
+  # process substitution in order to avoid disk IO operations.
+  #
+  # Also this module takes care of error handling and raises {Sox::Error} when
+  # a failure message is returned by the shell command.
+  #
+  # See http://en.wikipedia.org/wiki/Process_substitution
+  module Shell
+    # Path to the +bash+ interpreter:
+    BASH_PATH = '/bin/bash'
+
+    # Run a shell command.
+    #
+    # @param command [String] shell command to execute
+    #
+    # @return [Boolean] true in case of success
+    def sh(command)
+      _, _, err_io, thread = Open3.popen3(command)
+      thread.join
+
+      process_status = thread.value
+      if process_status.success?
+        true
+      else
+        raise Error, err_io.read
+      end
+    rescue Errno::ENOENT => err
+      msg = "#{err.message}. Do you have `#{SOX_COMMAND}' installed?"
+      raise Error, msg
+    end
+
+    # Run bash command.
+    #
+    # @param command [String] bash command to execute
+    #
+    # @return [Boolean] true in case of success
+    def bash(command)
+      bash_command = "#{BASH_PATH} -c #{Shellwords.escape(command)}"
+      sh(bash_command)
+    end
+  end
+end

data/lib/sox.rb

@@ -0,0 +1,19 @@
+require 'shellwords'
+require 'open3'
+require 'tempfile'
+
+# Wrapper around the +sox+ command line tool.
+module Sox
+  # Basic SoX error:
+  class Error < StandardError
+  end
+
+  # The SoX command:
+  SOX_COMMAND = 'sox'.freeze
+end
+
+require 'sox/file'
+require 'sox/shell'
+require 'sox/command_builder'
+require 'sox/cmd'
+require 'sox/combiner'

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: ruby-sox
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Potapov Sergey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: guard-rspec
+  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: metric_fu
+  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: Wrapper around sox sound tool
+email: blake131313@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.markdown
+files:
+- LICENSE.txt
+- README.markdown
+- lib/ruby-sox.rb
+- lib/sox.rb
+- lib/sox/cmd.rb
+- lib/sox/combiner.rb
+- lib/sox/combiner/base_strategy.rb
+- lib/sox/combiner/process_substitution_strategy.rb
+- lib/sox/combiner/tmp_file_strategy.rb
+- lib/sox/command_builder.rb
+- lib/sox/file.rb
+- lib/sox/shell.rb
+homepage: http://github.com/greyblake/ruby-sox
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Wrapper around sox sound tool
+test_files: []
+has_rdoc: