serinette 0.0.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a03120ebbc77c513989a69ab9fa002778e2a8f7a
+  data.tar.gz: a5da094dd669c14f50cfa9d633bae4b9f9b0d7af
+SHA512:
+  metadata.gz: 8b26b0a300b81bae7e6bd926c851ba3347d99a4c65283aafb8d3de4fd342e463e70012b0a7e9c4c972373eba2cb144aca9dcd3b28f413225d7379327641d64d7
+  data.tar.gz: 3bd31184c2062eae9d1fbe3f34f9b47b2a1adb22e6db3d37877a1cf0298b6b37e69bbe4b942914c8b33d4d3ce61e8f312f8735bcd5fca12c75d1ff70db2bbefe

data/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_WITHOUT: development

data/.gitignore

@@ -0,0 +1,7 @@
+tmp/**/*
+coverage
+!tmp/.gitkeep
+.inch
+.bundle
+*.gem
+Gemfile.lock

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,23 @@
+# still in beta
+# os:
+#   - linux
+#   - osx
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0
+  - ruby-head
+  - jruby-head
+notifications:
+  slack:
+    secure: KCr8I8N78I0wOX5Cx8nJwPMM7jEDEPHI9z2RCIaANLy+sdFkV3Jz1RAx/6F4hctVzHHDWirZ7lWjRwljuBtV31rTSga1YRInxXvreWyLorN6stZAC4ZGZG4SMqUZCeAmgKp2WdweYeRAHLOy2fW9jLeoBOFtyl8PkooHmob7isA=
+addons:
+  code_climate:
+    repo_token: e470e0610710700b03b559ceb7cbe2972d02735cc687a4dd6c2dac6f86fc4950
+virtualenv:
+  system_site_packages: true
+before_install:
+  - sudo apt-get install sox
+script: bundle exec rake travis_spec

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Change log
+
+## master
+
+## 0.0.0 (today
+
+### Bugs fixed
+
+* Makin it suck less
+* Tryna get it to work and stuff

data/CONTRIBUTING.md

@@ -0,0 +1,3 @@
+# Contributing
+
+I wouldn't bother.

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+group :development do
+  gem 'rubocop', '0.29.1', require: false
+  gem 'inch', '0.5.10', require: false
+end
+
+group :test do
+  gem 'coveralls', '0.7.10'
+  gem 'codeclimate-test-reporter', '0.4.6'
+end
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jared Clifton
+
+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,107 @@
+# [serinette](http://jclif.github.io/serinette/)
+
+Generates music from the command line.
+
+[![Code Climate](https://codeclimate.com/github/jclif/serinette/badges/gpa.svg)](https://codeclimate.com/github/jclif/serinette)
+[![Build Status](https://travis-ci.org/jclif/serinette.svg?branch=master)](https://travis-ci.org/jclif/serinette)
+[![Code Climate](https://codeclimate.com/github/jclif/serinette/badges/gpa.svg)](https://codeclimate.com/github/jclif/serinette)
+[![Dependency Status](https://gemnasium.com/jclif/serinette.svg)](https://gemnasium.com/jclif/serinette)
+[![Documentation](https://inch-ci.org/github/jclif/serinette.svg?branch=master)](https://inch-ci.org/github/jclif/serinette)
+[![Chatroom](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/jclif/serinette?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Stories in Ready](https://badge.waffle.io/jclif/serinette.png?label=ready&title=Ready)](https://waffle.io/jclif/serinette)
+
+## Installation
+
+Wow, what helpful installation instructions.
+
+```
+gem install yada-yada-dont-actually-run-this-please
+```
+
+## Basic Usage
+
+We're not quite there yet. Get off my back, brah. It'll work something like this though:
+
+```
+serinette orchestrate
+```
+
+Alternatively you can pass serinette a list of amazing flags and arguments and stuff (you can't)
+
+```
+serinette orchestrate --wow -f me
+```
+
+For more details check the available command-line options (none of these work at all, please just go away):
+
+```
+serinette -h
+```
+
+Command flag              | Description
+--------------------------|------------------------------------------------------------
+`-v/--version`            | Displays the current version and exits.
+`-V/--verbose-version`    | Displays the current version plus the version of Parser and Ruby.
+`-d/--debug`              | Displays some extra debug output.
+`-f/--format`             | Choose a formatter.
+
+##Configuration
+
+The behavior of Serinette can be controlled via the why_are_you_still_readying_this.yml
+
+```
+Cool: A value or something
+
+Style:
+  Enabled: OhYes
+```
+
+## Team
+
+Here's a list of Serinette's core developers:
+
+* [Yours Truly](https://github.com/jclif)
+* [Austin Gatlin](https://github.com/aegnog)
+
+## Logo
+
+We don't have one. Thanks for asking.
+
+If we did, it would be licensed under a
+[Creative Commons Attribution-NonCommercial 4.0 International License](http://creativecommons.org/licenses/by-nc/4.0/deed.en_GB).
+
+## Contributors
+
+Here's a [list](https://github.com/jclif/serinette/contributors) of
+all the people who have contributed to the development of Serinette.
+
+Thank you SOOOO much (me)!
+
+If you'd like to contribute to Serintte, please take the time to go
+through our short
+[contribution guidelines](CONTRIBUTING.md).
+
+You can also support my work on Serinette and
+[all my other projects](https://github.com/jclif) via
+[gratipay](https://www.gratipay.com/jclif), but why would you ever want to.
+
+[![Support via Gratipay](http://img.shields.io/gratipay/jclif.svg)](https://gratipay.com/jclif/)
+
+## Mailing List
+
+If you're interested in everything regarding Serinette development,
+I'm sorry there is nothing I can do for you. Do people use google groups for this
+[Google Group](https://groups.google.com/).
+
+## Freenode
+
+What's that.
+
+## Changelog
+
+Serinette's changelog is available [here](CHANGELOG.md).
+
+## Copyright
+
+Copyright (c) 2015 Jared Clifton. See [LICENSE.txt](LICENSE.txt) for
+further details.

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rspec'
+require 'rspec/core/rake_task'
+require './dependencies.rb'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.fail_on_error = false
+  t.rspec_opts = ['--format documentation', '--color', '--order=default']
+  t.pattern = ARGV[1] || 'spec/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new(:travis_spec) do |t|
+  t.fail_on_error = true
+  t.pattern = ARGV[1] || 'spec/**/*_spec.rb'
+end
+
+task default: :spec

data/dependencies.rb

@@ -0,0 +1,4 @@
+require 'cliver'
+
+# make sure we have all of our cli dependencies
+Cliver.detect!('sox')

data/lib/mixins/descendents.rb

@@ -0,0 +1,15 @@
+module Serinette
+  # Gives mixed in classes a method for returning an array of their descendents
+  module Descendents
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # required for inheritance
+    module ClassMethods
+      def descendents
+        ObjectSpace.each_object(Class).select { |klass| klass < self }
+      end
+    end
+  end
+end

data/lib/mixins/sox_options.rb

@@ -0,0 +1,59 @@
+module Serinette
+  # Gives mixed in classes a method for randomizing effect options
+  module SoxOptions
+    # Takes a sox effect config and returns randomized Hash.
+    #
+    # @param config [Array] Sox effect options config
+    #
+    # @return [string] Randomized effect hash to be used with Sox::Cmd.set_effects
+    def self.randomize_options_as_string(configs)
+      configs.map do |o|
+        stringify_option(o)
+      end.compact.join(' ')
+    end
+
+    # Takes an individual option and checks for type, (if flag, its either on of
+    # off; if traig, randomize within the range given
+    #
+    # @param option [Option] Sox effect option
+    # Looks like this:
+    #   {
+    #     type: :flag,
+    #     name: 'wet-only',
+    #     value: '-w'
+    #   }
+    # or this:
+    #   {
+    #     type: :trait,
+    #     name: 'reverberance',
+    #     range: (0..100), <== this can be an array or range, and it should sample
+    #     default: 50
+    #   {
+    #
+    # @return [string] Randomized effect hash to be used with Sox::Cmd.set_effects
+    def self.stringify_option(option)
+      case option[:type]
+      when :flag
+        return [true, false].sample ? option[:value] : nil
+      when :trait # TODO add check for proc here
+        return process_trait(option[:value])
+      else
+        fail Serinette::Error, '#stringify_option requires type of flag or trait'
+      end
+    end
+
+    def self.process_trait(trait)
+      case trait
+      when Range
+        return trait.to_a.sample
+      when Array
+        return trait.sample
+      when Proc
+        return trait.call
+      else
+        msg = '#process_trait requires trait of type Array, Range, or Proc'
+        fail Serinette::Error, msg
+      end
+    end
+  end
+end

data/lib/serinette/effect.rb

@@ -0,0 +1,22 @@
+module Serinette
+  # Used to get subclasses and generate sox commands
+  class Effect
+    include Descendents
+    include SoxOptions
+
+    # Gets a specified number of Effect subclasses.
+    #
+    # @param num [Fixnum] Number of effects
+    # @return [Array] An array of Effect subclasses
+    def self.sample_effects_classes(num)
+      Array.new(num).map do
+        Effect.descendents.sample.new
+      end
+    end
+
+    # Gets a key pair for a given sox effect and its args
+    def to_sox_key_pair
+      { return_root_command => generate_options }
+    end
+  end
+end

data/lib/serinette/noise.rb

@@ -0,0 +1,19 @@
+module Serinette
+  # Most basic unit of sound; will eventually provide base class for many
+  # different kinds of noises (SynthNoise, SourceNoise, etc)
+  class Noise
+    include Descendents
+
+    attr_accessor :wavefile
+
+    # Gets a specified number of Noise subclasses.
+    #
+    # @param num [Fixnum] Number of noises
+    # @return [Array] An array of Noise subclasses
+    def self.sample_noise_classes(num = 1)
+      Array.new(num).map do
+        Noise.descendents.sample
+      end
+    end
+  end
+end

data/lib/serinette/reverb_effect.rb

@@ -0,0 +1,63 @@
+module Serinette
+  # Reverb type of effect
+  class ReverbEffect < Effect
+    ROOT_COMMAND = 'reverb'.freeze
+
+    # Sox options:
+    # -w|--wet-only [on - off]
+    # reverberance (50%) [0 - 100]
+    # HF-damping (50%) [0 - 100]
+    # room-scale (100%) [0 - 100]
+    # stereo-depth (100%) [0 - 100]
+    # pre-delay (0ms) [0] TODO dtermine max pre-delay
+    # wet-gain (0dB) [-10 - 10] TODO dB range
+    SOX_OPTIONS_CONFIG = [
+      {
+        type: :flag,
+        name: 'wet-only',
+        value: '-w'
+      }, {
+        type: :trait,
+        name: 'reverberance',
+        value: (0..100),
+        default: 50
+      }, {
+        type: :trait,
+        name: 'HF-damping',
+        value: (0..100),
+        default: 50
+      }, {
+        type: :trait,
+        name: 'room-scale',
+        value: (0..100),
+        default: 100
+      }, {
+        type: :trait,
+        name: 'stereo-depth',
+        value: (0..100),
+        default: 100
+      }, {
+        type: :trait,
+        name: 'pre-delay',
+        value: (0..5),
+        default: 0
+      }, {
+        type: :trait,
+        name: 'wet-gain',
+        value: (-10..10),
+        default: 0
+      }
+    ]
+
+    # Passes in the Effect Subclasses config to generate sox option hash
+    #
+    # @return [String] Result of randomized string representation of options
+    def generate_options
+      SoxOptions.randomize_options_as_string(SOX_OPTIONS_CONFIG)
+    end
+    # Sox command
+    def return_root_command
+      ROOT_COMMAND
+    end
+  end
+end

data/lib/serinette/song.rb

@@ -0,0 +1,70 @@
+module Serinette
+  # Has functions for kicking off initializer chain, rendering final song, and
+  # constants necessary for determining song-level characteristcs
+  class Song
+    LOWEST_DURATION  = 60
+    HIGHEST_DURATION = 180
+    TRACK_NUMBER     = 2
+    EFFECT_NUMBER    = 1
+
+    CHANNELS         = 2
+    RATE             = 99_600
+
+    attr_accessor :duration, :tracks, :effects
+
+    def self.default_effects
+      { rate: RATE, channels: CHANNELS }
+    end
+
+    def initialize
+      init_duration
+      init_tracks
+      init_effects
+    end
+
+    # Recurses render tree via render
+    def render
+      @tracks.map(&:render)
+    end
+
+    # Taks a sox instance and adds input, sets effects, and sets output
+    #
+    # @param sox [Sox::Cmd] Sox command instance
+    def configure_command(sox)
+      render.each do |file|
+        sox.add_input(file)
+      end
+      sox.set_effects(generate_effects_options)
+      sox.set_output(Serinette.output_path)
+    end
+
+    private
+
+    # Uses effects instance variable to generate hash of all effects as sox
+    # key/pairs
+    def generate_effects_options
+      effects_hash = Song.default_effects
+
+      @effects.each do |effect|
+        effects_hash.merge! effect.to_sox_key_pair
+      end
+
+      effects_hash
+    end
+
+    # Initializes duration
+    def init_duration
+      @duration = (LOWEST_DURATION..HIGHEST_DURATION).to_a.sample
+    end
+
+    # Initializes tracks
+    def init_tracks
+      @tracks = Array.new(TRACK_NUMBER) { Track.new }
+    end
+
+    # Initializes effects
+    def init_effects
+      @effects = Effect.sample_effects_classes(1)
+    end
+  end
+end

data/lib/serinette/source_noise.rb

@@ -0,0 +1,23 @@
+module Serinette
+  # Sourced Noises; will provide noises sourced from wav files found in a
+  # particular directory
+  class SourceNoise < Noise
+    SOUND_DIRECTORY = './data/sounds/*'
+
+    def initialize
+      init_wavefile
+    end
+
+    def init_wavefile
+      sox = SoxWrapper.generate_and_run input: SourceNoise.pick_random_file
+      @wavefile = sox.output.path
+    end
+
+    def self.pick_random_file
+      sound_files = Dir.glob(SOUND_DIRECTORY).sort
+      num = (0..sound_files.length - 1).to_a.sample
+
+      sound_files[num]
+    end
+  end
+end

data/lib/serinette/synth_noise.rb

@@ -0,0 +1,74 @@
+module Serinette
+  # Synthesized Noises; using arguments such as type (sin, square, saw) and will
+  # describe a subclass of Noises which corresponds to the use of the synth
+  # sox command
+  class SynthNoise < Noise
+    ROOT_COMMAND = 'synth'.freeze
+
+    # Sox options:
+    # len (0) [0 - 10] length in seconds TODO determine resonable range
+    # type (sine) [sine, square, triangle, sawtooth, trapezium, exp,
+    #   [white]noise, tpdfnoise pinknoise, brownnoise, pluck]
+    # combine (create) [create, mix, amod (amplitude modulation), fmod
+    #   (frequency modulation)]
+    # freq/freq2 (A4) [A0-G9:A0-G9] TODO expand stringify_options to allow for
+    #   swept or fixed frequencies; perhaps a lambda to generate both
+    #   thoughts: the freq can be given as a single note (fixed), or two (swept);
+    #   if swept notes are chosen, one of the following separators must be used:
+    #   ':' (linear) the tone will change by a fixed number of hertz per second
+    #   '+' (square) a second-order function is used to change the tone
+    #   '/' (exp) the tone will change by a fixed number of semitones per second
+    #   '-' (exp) link '/', but initial phase always zero, and stepped (rougher)
+    #     frequency changes
+    SOX_OPTIONS_CONFIG = [
+      {
+        type: :trait,
+        name: 'length',
+        value: (1..5), # cannot be zero, or will run indefinitely
+        default: 1
+      }, {
+        type: :trait,
+        name: 'type',
+        value: %w(sine square triangle sawtooth trapezium exp),
+        default: 'sine'
+      }, {
+        type: :trait,
+        name: 'combine',
+        value: %w(create mix amod fmod),
+        default: 'create'
+      }, {
+        type: :trait,
+        name: 'freq',
+        value: Proc.new do
+          freq = ('A'..'G').to_a.product((0..9).to_a).map { |el| el.join('') }.sample
+          if [true, false].sample
+            freq << [':','+','/','-'].sample
+            freq << ('A'..'G').to_a.product((0..9).to_a).map { |el| el.join('') }.sample
+          end
+          freq
+        end,
+        default: 'A4'
+      }
+    ]
+
+    def initialize
+      init_noise
+      apply_effects
+    end
+
+    def init_noise
+      sox_options = {
+        output: FileName::generate,
+        effects: {ROOT_COMMAND => SoxOptions::randomize_options_as_string(SOX_OPTIONS_CONFIG)}
+      }
+
+      SoxWrapper.generate_and_run(sox_options)
+
+      @wavefile = sox_options[:output]
+    end
+
+    def apply_effects
+      # TODO
+    end
+  end
+end

data/lib/serinette/track.rb

@@ -0,0 +1,24 @@
+module Serinette
+  # Contains noise, efects on noise, and when (timestamps) and
+  # how (volume) noise is played
+  class Track
+    attr_accessor :noise
+
+    def initialize
+      @noise = init_noise
+    end
+
+    # For now, just returns the result of noises render; this will be where
+    # the noise is brought in and out of the song
+    def render
+      @noise.wavefile
+    end
+
+    private
+
+    # Initializes noise
+    def init_noise
+      Noise.sample_noise_classes.first.new
+    end
+  end
+end

data/lib/serinette/version.rb

@@ -0,0 +1,3 @@
+module Serinette
+  VERSION = '0.0.0.pre'
+end

data/lib/serinette.rb

@@ -0,0 +1,57 @@
+require 'securerandom'
+
+require 'fileutils'
+require 'sox'
+
+require 'mixins/descendents'
+require 'mixins/sox_options'
+
+require 'utils/file_name'
+require 'utils/sox_wrapper'
+
+require 'serinette/effect'
+require 'serinette/reverb_effect'
+
+require 'serinette/noise'
+require 'serinette/synth_noise'
+require 'serinette/source_noise'
+
+require 'serinette/song'
+require 'serinette/track'
+
+# Contains functions for running essential commands and
+# defining app level constants
+module Serinette
+  OUTPUT_FILE_NAME = 'output'
+  TMP_DIR = './tmp/'
+  SOUND_FILE_TYPE = '.wav'
+
+  # Returns pull path of output file from project root
+  def self.output_path
+    Serinette::TMP_DIR +
+      Serinette::OUTPUT_FILE_NAME +
+      Serinette::SOUND_FILE_TYPE
+  end
+
+  # Removes all files in TMP_DIR of type SOUND_FILE_TYPE
+  def self.clean
+    FileUtils.rm_rf(Dir.glob("#{TMP_DIR}*#{SOUND_FILE_TYPE}"))
+  end
+
+  # Primary function for creating and outputing new songs
+  def self.orchestrate
+    clean
+
+    sox = Sox::Cmd.new(combine: :mix)
+
+    song = Song.new
+    song.configure_command(sox)
+    puts "Running sox with: #{sox.to_s}"
+
+    sox.run
+  end
+
+  # Basic Serinette error:
+  class Error < StandardError
+  end
+end

data/lib/utils/file_name.rb

@@ -0,0 +1,7 @@
+module Serinette
+  class FileName
+    def self.generate
+      "#{Serinette::TMP_DIR}#{SecureRandom.uuid}#{Serinette::SOUND_FILE_TYPE}"
+    end
+  end
+end

data/lib/utils/sox_wrapper.rb

@@ -0,0 +1,41 @@
+module Serinette
+  # Provides Sox helper functions
+  module SoxWrapper
+    # Takes options, generates a configured Sox::Cmd, and runs
+    #
+    # @params [Hash] options hash
+    # @returns [Sox::Cmd] Sox command with all configurations
+    def self.generate_and_run(options = {})
+      setup(options, true)
+    end
+
+    # Takes options and generates a configured Sox::Cmd
+    #
+    # @params [Hash] options hash
+    # @returns [Sox::Cmd] Sox commands with all configurations
+    def self.generate(options = {})
+      setup(options, false)
+    end
+
+    private
+
+    # Internal function for setting up and running (if should_run) sox command
+    def self.setup(options, should_run)
+      options[:global_options] ||= {}
+      options[:input] ||= '-n'
+      options[:output] ||= FileName.generate
+      options[:effects] ||= {}
+
+      options[:effects].merge! Song::default_effects
+
+      sox = Sox::Cmd.new options[:global_options]
+
+      sox.add_input(options[:input])
+      sox.set_effects(options[:effects])
+      sox.set_output(options[:output])
+
+      sox.run if should_run
+      sox
+    end
+  end
+end

data/serinette.gemspec

@@ -0,0 +1,25 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "serinette/version"
+
+Gem::Specification.new do |gem|
+  gem.name          = 'serinette'
+  gem.version       = Serinette::VERSION
+  gem.summary       = "Random music from the command line."
+  gem.description   = "Serinette is a library with a strongly opionated approach to generating random music from the command line."
+  gem.authors       = ['Jared Clifton', 'Austin Gatlin']
+  gem.email         = 'jaredcraigclifton@gmail.com'
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ['lib']
+  gem.homepage      = 'http://jclif.github.io/serinette/'
+  gem.license       = 'MIT'
+
+  gem.required_ruby_version = '>= 1.9.3'
+
+  gem.add_dependency 'cliver', '0.3.2'
+  gem.add_dependency 'ruby-sox', '0.0.3'
+
+  gem.add_development_dependency 'rake', '10.4.2'
+  gem.add_development_dependency 'rspec', '3.2.0'
+end

data/spec/serinette/effect_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Serinette::Effect do
+  describe '.sample_effects_classes' do
+    it 'should exist' do
+      expect(Serinette::Effect).to respond_to(:sample_effects_classes)
+    end
+  end
+
+  context 'given an effect' do
+    subject(:effect) { Serinette::Effect.new }
+    it 'should have a method #to_sox_key_pair' do
+      expect(effect).to respond_to(:to_sox_key_pair)
+    end
+  end
+end

data/spec/serinette/mixins/descendents_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Serinette::Descendents do
+  let(:klass) { Class.new { include Serinette::Descendents } }
+
+  context 'a class method #descendents' do
+    it 'should exist in classes which include the module' do
+      expect(klass).to respond_to(:descendents)
+    end
+
+    it 'should return a classes descendents' do
+      class Subklass1 < klass; end
+      class Subklass2 < klass; end
+      expect(klass.descendents - [Subklass1, Subklass2]).to eq []
+    end
+  end
+end

data/spec/serinette/mixins/sox_options_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Serinette::SoxOptions do
+  context 'a method #randomize_options_as_string' do
+    it 'should exist' do
+      expect(Serinette::SoxOptions).to respond_to(:randomize_options_as_string)
+    end
+  end
+
+  context 'a method #stringify_option' do
+    it 'should exist' do
+      expect(Serinette::SoxOptions).to respond_to(:stringify_option)
+    end
+
+    it 'should return correct string when given type: :flag' do
+      good_option1 = {
+        type: :flag,
+        name: 'wet-only',
+        value: '-w'
+      }
+
+      allow_any_instance_of(Array).to receive(:sample).and_return(true)
+      expect(Serinette::SoxOptions.stringify_option(good_option1)).to eq('-w')
+    end
+
+    it 'should return correct string when given type: :trait as range' do
+      good_option2 = {
+        type: :trait,
+        name: 'reverberance',
+        value: (0..100),
+        default: 50
+      }
+
+      result = Serinette::SoxOptions.stringify_option(good_option2)
+
+      expect(result).not_to be_nil
+      expect(result.to_i).to be_between(0, 100)
+    end
+
+    it 'should return correct string when given type: :trait as array' do
+      good_option2 = {
+        type: :trait,
+        name: 'reverberance',
+        value: [0, 50, 100],
+        default: 50
+      }
+
+      allow_any_instance_of(Array).to receive(:sample).and_return(50)
+
+      result = Serinette::SoxOptions.stringify_option(good_option2)
+
+      expect(result).not_to be_nil
+      expect(result.to_i).to eq(50)
+    end
+
+    it 'should return correct string when given type: :trait as proc'
+
+    it 'should fail when type is bad' do
+      bad_option = {
+        type: :bad,
+        name: 'wet-only',
+        value: '-w'
+      }
+
+      error = Serinette::Error
+      expect { Serinette::SoxOptions.stringify_option(bad_option) }.to raise_error(error)
+    end
+  end
+end

data/spec/serinette/noise_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Serinette::Noise do
+  it 'should have a method #sample_noise_classes' do
+    expect(Serinette::Noise).to respond_to(:sample_noise_classes)
+  end
+end

data/spec/serinette/reverb_effect_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Serinette::ReverbEffect do
+  subject(:reverb_effect) { Serinette::ReverbEffect.new }
+
+  it 'should inherit from Effect' do
+    Serinette::ReverbEffect.ancestors.include?(Serinette::Effect)
+  end
+end

data/spec/serinette/song_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Serinette::Song do
+  it 'should have a constant TRACK_NUMBER' do
+    expect(Serinette::Song).to have_constant(:TRACK_NUMBER)
+  end
+
+  it 'should have a constant EFFECT_NUMBER' do
+    expect(Serinette::Song).to have_constant(:EFFECT_NUMBER)
+  end
+
+  it 'should have a constant CHANNELS' do
+    expect(Serinette::Song).to have_constant(:CHANNELS)
+  end
+
+  it 'should have a constant RATE' do
+    expect(Serinette::Song).to have_constant(:RATE)
+  end
+
+  describe '.default_effects' do
+    it 'should exist' do
+      expect(Serinette::Song).to respond_to(:default_effects)
+    end
+
+    it 'should get output path' do
+      default_effects = { rate: Serinette::Song::RATE, channels: Serinette::Song::CHANNELS }
+      expect(Serinette::Song.default_effects).to eq default_effects
+    end
+  end
+
+  context 'given a song' do
+    subject(:song) { Serinette::Song.new }
+
+    it 'should have correct number of effects' do
+      expect(song.effects.length).to be Serinette::Song::EFFECT_NUMBER
+    end
+
+    it 'should have correct number of tracks' do
+      expect(song.tracks.length).to be Serinette::Song::TRACK_NUMBER
+    end
+
+    it 'should have a variable duration' do
+      expect(song.duration).to be_a Fixnum
+    end
+
+    it 'should have a duration less than three minutes' do
+      expect(song.duration).to be <= 180
+    end
+
+    it 'should have a duration more than one minute' do
+      expect(song.duration).to be >= 60
+    end
+
+    it 'should have tracks' do
+      expect(song.tracks).to be_a Array
+    end
+
+    it 'should have effects' do
+      expect(song.effects).to be_a Array
+    end
+
+    it 'should have correct number of tracks' do
+      expect(song.tracks.length).to be Serinette::Song::TRACK_NUMBER
+      song.tracks.each do |track|
+        expect(track).to be_a Serinette::Track
+      end
+    end
+
+    it 'should call render on all tracks' do
+      song.tracks.each do |track|
+        expect(track).to receive(:render)
+      end
+
+      song.render
+    end
+  end
+end

data/spec/serinette/source_noise_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Serinette::SourceNoise do
+
+  it 'should inherit from Noise' do
+    expect(Serinette::SourceNoise.ancestors.include?(Serinette::Noise)).to eq(true)
+  end
+
+  context 'given a source noise' do
+    subject(:source_noise) { Serinette::SourceNoise.new }
+
+    it 'should have a wavefile' do
+      expect(source_noise.wavefile).to be_a String
+    end
+  end
+end

data/spec/serinette/synth_noise_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Serinette::SynthNoise do
+  it 'should have a constant SOX_OPTIONS_CONFIG' do
+    expect(Serinette::SynthNoise).to have_constant(:SOX_OPTIONS_CONFIG)
+  end
+
+  it 'should inherit from Noise' do
+    expect(Serinette::SynthNoise.ancestors.include?(Serinette::Noise)).to eq(true)
+  end
+end

data/spec/serinette/track_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Serinette::Track do
+  context 'given a track' do
+    subject(:track) { Serinette::Track.new }
+
+    it 'should have a noise' do
+      expect(track.noise).to be_a Serinette::Noise
+    end
+
+    it 'should have method render that creates a tem file and returns the path' do
+      file_name = track.render
+      expect(File.exist?(file_name)).to be true
+    end
+  end
+end

data/spec/serinette/utils/file_name_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Serinette::FileName do
+  context 'a class method #generate' do
+    it 'should exist' do
+      expect(Serinette::FileName).to respond_to(:generate)
+    end
+
+    it 'should return a string' do
+      expect(Serinette::FileName.generate).to be_a String
+    end
+
+    it 'should be random'
+
+  end
+end

data/spec/serinette/utils/sox_wrapper_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Serinette::SoxWrapper do
+  context 'a class method #generate' do
+    it 'should exist' do
+      expect(Serinette::SoxWrapper).to respond_to(:generate)
+    end
+
+    it 'should return a Sox::Cmd' do
+      expect(Serinette::SoxWrapper.generate).to be_a Sox::Cmd
+    end
+
+    it 'should configure the Sox::Cmd correctly'
+  end
+end

data/spec/serinette_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Serinette do
+  it 'should have a variable called OUTPUT_FILE_NAME' do
+    expect(Serinette::OUTPUT_FILE_NAME).not_to be_nil
+  end
+
+  it 'should have a variable called TMP_DIR' do
+    expect(Serinette::TMP_DIR).not_to be_nil
+  end
+
+  it 'should have a variable called SOUND_FILE_TYPE' do
+    expect(Serinette::SOUND_FILE_TYPE).not_to be_nil
+  end
+
+  describe '.clean' do
+    it 'should exist' do
+      expect(Serinette).to respond_to(:clean)
+    end
+
+    it 'should remove all wav files from the tmp directory' do
+      file_name = "#{Serinette::TMP_DIR}test.#{Serinette::SOUND_FILE_TYPE}"
+      FileUtils.touch(file_name)
+      Serinette.clean
+      expect(File.exist?(file_name)).to be false
+    end
+  end
+
+  describe '.output_path' do
+    it 'should exist' do
+      expect(Serinette).to respond_to(:output_path)
+    end
+
+    it 'should get output path' do
+      path = Serinette::TMP_DIR +
+             Serinette::OUTPUT_FILE_NAME +
+             Serinette::SOUND_FILE_TYPE
+      expect(Serinette.output_path).to eq path
+    end
+  end
+
+  describe '.orchestrate' do
+    it 'should exist' do
+      expect(Serinette).to respond_to(:orchestrate)
+    end
+
+    it 'should output a file' do
+      Serinette.orchestrate
+      expect(File.exist?(Serinette.output_path)).to be true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+# require 'coveralls'
+require 'codeclimate-test-reporter'
+
+# Coveralls.wear!
+CodeClimate::TestReporter.start
+
+require 'serinette'
+
+# Custom Matchers
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}

data/spec/support/matchers/have_constant.rb

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :have_constant do |const|
+  match do |owner|
+    owner.const_defined?(const)
+  end
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: serinette
+version: !ruby/object:Gem::Version
+  version: 0.0.0.pre
+platform: ruby
+authors:
+- Jared Clifton
+- Austin Gatlin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cliver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+- !ruby/object:Gem::Dependency
+  name: ruby-sox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: Serinette is a library with a strongly opionated approach to generating
+  random music from the command line.
+email: jaredcraigclifton@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".bundle/config"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- data/sounds/haunting_voices.wav
+- data/sounds/hypnotic_loop.wav
+- dependencies.rb
+- lib/mixins/descendents.rb
+- lib/mixins/sox_options.rb
+- lib/serinette.rb
+- lib/serinette/effect.rb
+- lib/serinette/noise.rb
+- lib/serinette/reverb_effect.rb
+- lib/serinette/song.rb
+- lib/serinette/source_noise.rb
+- lib/serinette/synth_noise.rb
+- lib/serinette/track.rb
+- lib/serinette/version.rb
+- lib/utils/file_name.rb
+- lib/utils/sox_wrapper.rb
+- serinette.gemspec
+- spec/serinette/effect_spec.rb
+- spec/serinette/mixins/descendents_spec.rb
+- spec/serinette/mixins/sox_options_spec.rb
+- spec/serinette/noise_spec.rb
+- spec/serinette/reverb_effect_spec.rb
+- spec/serinette/song_spec.rb
+- spec/serinette/source_noise_spec.rb
+- spec/serinette/synth_noise_spec.rb
+- spec/serinette/track_spec.rb
+- spec/serinette/utils/file_name_spec.rb
+- spec/serinette/utils/sox_wrapper_spec.rb
+- spec/serinette_spec.rb
+- spec/spec_helper.rb
+- spec/support/matchers/have_constant.rb
+- tmp/.gitkeep
+homepage: http://jclif.github.io/serinette/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Random music from the command line.
+test_files:
+- spec/serinette/effect_spec.rb
+- spec/serinette/mixins/descendents_spec.rb
+- spec/serinette/mixins/sox_options_spec.rb
+- spec/serinette/noise_spec.rb
+- spec/serinette/reverb_effect_spec.rb
+- spec/serinette/song_spec.rb
+- spec/serinette/source_noise_spec.rb
+- spec/serinette/synth_noise_spec.rb
+- spec/serinette/track_spec.rb
+- spec/serinette/utils/file_name_spec.rb
+- spec/serinette/utils/sox_wrapper_spec.rb
+- spec/serinette_spec.rb
+- spec/spec_helper.rb
+- spec/support/matchers/have_constant.rb
+has_rdoc: