musikov 0.15

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2012, André de Amorim Fonseca
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies, 
+either expressed or implied, of the FreeBSD Project.

data/README.md

@@ -0,0 +1,46 @@
+## musikov
+
+Random midi generator based on Markov Chains. (Make heavy use of [Midilib](https://github.com/jimm/midilib))
+
+The model is quite simple: from a set of songs, a |Note, Duration| graph will be generated where the edges will indicate the probability of transitions between two of these states. A graph will be generated for each instrument on the input set of midifiles.
+
+A song is generated randomically from an inital state, picking the subsequent states according the indicated probability.
+
+More inform about Markov Chains : http://en.wikipedia.org/wiki/Markov_chain
+
+## Installation
+
+### RubyGems instalation
+
+```bash
+gem install musikov
+```
+
+or, in order to update the gem:
+
+```bash
+gem update musikov
+```
+
+You may need root privileges to install the gem.
+
+## How to use it
+
+First launch the musikov passing a midi file, or a folder containg midi files, as the main argument:
+
+    $ musikov generate -r path-to-midis [-o output_file]
+
+The musikov will output a random midi file named output.mid (by default), or the indicated file if the option '-o' is used.
+
+## TODO
+
+ - Define an option for the duration of the songs by time or by number of notes.
+ - Maybe classify different sacles in order to aproximate a generated song to the predominant scale.
+
+## Author
+
+Andre Fonseca <andre.amorimfonseca@gmail.com>
+
+## License
+
+Simplified BSD

data/bin/musikov

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+#----------------------------------------------------------------------------------------
+# The program takes an initial midi file (or folder with many midis) path
+# from the command line. It will generate a random midi file from the input
+# based on a Markov Chain model.
+#
+# Author::    André Fonseca
+# License::   Simplified BSD
+#----------------------------------------------------------------------------------------
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib') unless $LOAD_PATH.include?(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'musikov'
+require 'thor'
+require 'midilib/consts'
+
+class MusikovStarter < Thor
+
+  include Thor::Actions
+  
+  desc "generate", "generate random midi from input midi files"
+  method_option :resources, :aliases => "-r", :type => :array, :desc => "File or folder list containing the input midi files."
+  method_option :output_folder, :aliases => "-o", :type => :string, :desc => "Output folder."
+  def generate
+    begin
+      repository = Musikov::MarkovRepository.new
+      say "Learning midi sequence from resources :"
+      print_in_columns options[:resources]
+      repository.import options[:resources]
+      say "\nFiles successfully imported!", Thor::Shell::Color::GREEN
+      say "\nGenerating your random midi..."
+      generate_midi(repository, options[:output_folder])
+    rescue
+      say "There was a problem importing the selected files : #{$!.message} => #{$!.backtrace.join("\n")}", Thor::Shell::Color::RED
+    end
+  end
+  
+  desc "generate_midi", "midi_generation task", :hide => true
+  def generate_midi(repository, path)
+    say "Select the instruments you would like to include in the output file:"
+    
+    # Shows the instruments options to the user
+    opts = {}
+    repository.models_by_instrument.each_with_index { |(program_change, hash), index|
+      instrument = MIDI::GM_PATCH_NAMES[program_change]
+      say "#{index + 1} : #{instrument}"
+      opts[index + 1] = program_change
+    }
+    say "* : all instruments => Default"
+    
+    # Asks for the instrument selection. Non selected instruments will be excluded from the model.
+    # By default it will include everything...
+    res = ask "\nSelect (ex: 1 2 3):", Thor::Shell::Color::YELLOW
+    instruments = []
+    res.split.each { |opt|
+      if (opt.to_i != 0) then
+        instruments << opts[opt.to_i] unless opts[opt.to_i].nil?
+      end
+    }
+    
+    # Selects all instruments if none was pick
+    instruments += opts.values if instruments.empty?
+    
+    # Excluding non selected instruments...
+    repository.models_by_instrument.delete_if { |instrument, markov_chain|
+      !instruments.include?(instrument) || markov_chain.frequencies.empty?
+    }
+    
+    # Picking song from model...
+    sequences = {}
+    repository.models_by_instrument.each { |instrument, markov_chain|
+       sequences[instrument] = markov_chain.generate(nil, 50)
+    }
+    
+    # Writing in the output file...
+    unless path.nil? then
+      repository.export(sequences, path)
+    else
+      repository.export(sequences)
+    end
+    
+    say "\nSuccess: output file generated in output.mid!", Thor::Shell::Color::GREEN
+  end
+  
+end
+
+MusikovStarter.start

data/lib/musikov.rb

@@ -0,0 +1,10 @@
+
+module Musikov
+  
+  VERSION = "0.1"
+ 
+end
+
+require 'musikov/markov_builder'
+require 'musikov/markov_model'
+require 'musikov/midi_parser'

data/lib/musikov/markov_builder.rb

@@ -0,0 +1,232 @@
+require 'musikov/midi_parser.rb'
+require 'musikov/midi_writer.rb'
+require 'musikov/markov_model.rb'
+
+module Musikov
+
+
+# This class holds the markov chains of each
+# instrument built from the selected midi files.
+class MarkovRepository
+  
+  attr_accessor :models_by_instrument
+  
+  # Initialize the map of markov chain by instrument
+  def initialize
+    @models_by_instrument = {}
+  end
+  
+  # Call parser over indicated paths and trigger the 
+  # markov chain building process.
+  # * the paths can be either folders or files
+  # * the file indicated by the path must exist!
+  def import(paths = [])
+    parser = MidiParser.new(paths)
+    sequencies = parser.parse
+    
+    builder = MarkovBuilder.new()
+    sequencies.each { |sequency|
+      builder.add(sequency)
+    }
+    
+    @models_by_instrument = builder.build
+  end
+  
+  # Export the generated chains
+  def export(sequence_hash = {}, path = ".")
+    writer = MidiWriter.new(path)
+    writer.write(sequence_hash)
+  end
+  
+end
+
+# This class is responsible for building the markov
+# chain map from midi sequences. For every sequence,
+# a "quarter" duration will be extracted and every note
+# duration will be mapped in the possible values on the
+# duration table. From a note and a specifc duration,
+# MidiElements will be created representing a state on the
+# markov chain. 
+class MarkovBuilder
+  
+  ####################
+  public
+  ####################
+  
+  # Initialize the hashes used to build the markov chain of note elements.
+  # * The value_chain is a hash containing a list of note events by instrument.
+  # * The duration table is a dynamic generated hash (generated from the "quarter" duration value) that maps
+  # a the duration of the notes to a string representation.
+  def initialize
+    @value_chain = Hash.new
+    @duration_table = Hash.new("unknow")
+  end
+  
+  # Add a midi sequence to the model. From each sequence,
+  # different tracks (instruments) will be analyzed. Each
+  # sequence has a "tempo" that defines the "quarter" duration in ticks.
+  # From the "quarter" duration, creates a duration table containg (almost)
+  # every possible note duration.
+  # Creates markov chain elements by the value of the played note and the
+  # duration string mapped from the duration table.
+  def add(sequence)
+    # Obtains a quarter duration for this sequence
+    quarter_note_length = sequence.note_to_delta('quarter')
+    
+    # Create the duration table based on the sequence's "quarter" value
+    create_duration_table(quarter_note_length)
+    
+    # For each instrument on the sequence...
+    sequence.each { |track|
+      # Program change of the current track
+      program_change = nil
+
+      # Create a list of midi elements for an instrument
+      elements = []
+
+      # Iterates the track event list...
+      track.each { |event|
+        
+        # Consider only "NoteOn" events since they represent the start of a note event (avoid duplication with "NoteOff").
+        if event.kind_of?(MIDI::NoteOnEvent) then
+          # From its correspondent "NoteOff" element, extract the duration of the note event.
+          duration = event.off.time_from_start - event.time_from_start + 1
+          
+          # Maps the duration in ticks to a correspondent string on the duration table.
+          duration_representation = @duration_table[duration]
+          
+          # In the case that the note do not correspond to anything in the table,
+          # we just truncate it to the closest value.
+          if duration_representation.nil? or duration_representation == "unknow" then
+            new_duration = 0
+            # Infinity value simulation
+            smallest_difference = 1.0/0
+            @duration_table.each { |key, value|
+              difference = (duration - key).abs
+              if difference < smallest_difference then
+                smallest_difference = difference
+                new_duration = key
+              end
+            }
+            duration_representation = @duration_table[new_duration]
+          end
+
+          # Create new markov chain state and put into the "elements" list
+          elements << MidiElement.new(event.note_to_s, duration_representation)
+        elsif event.kind_of?(MIDI::ProgramChange) then
+          program_change = event.program
+        end
+      }
+      
+      if program_change.nil?
+        program_change = 1
+      end
+      
+      @value_chain[program_change] ||= elements unless elements.empty?
+    }
+  end
+  
+  # Build the markov chain for each instrument on the input midi file(s)
+  def build
+    model_by_instrument = {}
+    @value_chain.each{ |key, value|
+      model_by_instrument[key] = MarkovModel.new(value)
+    }
+    
+    return model_by_instrument
+  end
+  
+  ####################
+  private
+  ####################
+  
+  # Creates the duration table from the "quarter" note duration in ticks.
+  # * The quarter note duration will change for every track!
+  def create_duration_table(quarter_note_length)
+    # Fuck it if the song have two dots or a combination of dots and "three"...
+    whole = (quarter_note_length * 4)
+    dotted_whole = (quarter_note_length * 6)
+    whole_triplet = (8 * quarter_note_length / 3)
+    half = (quarter_note_length * 2)
+    dotted_half = (quarter_note_length * 3)
+    half_three = (whole / 3)
+    dotted_quarter = (quarter_note_length * 1.5)
+    quarter_triplet = (half / 3)
+    eight = (quarter_note_length / 2)
+    eight_triplet = (quarter_note_length / 3)
+    dotted_eight = (3 * quarter_note_length / 4)
+    sixteenth = (quarter_note_length / 4)
+    sixteenth_triplet = (eight / 3)
+    dotted_sixteenth = (3 * quarter_note_length / 8)
+    thirty_second = (quarter_note_length / 8)
+    thirty_second_triplet = (sixteenth / 3)
+    dotted_thirty_second = (3 * quarter_note_length / 16)
+    sixty_fourth = (quarter_note_length / 16)
+    sixty_fourth_triplet = (thirty_second / 3)
+    dotted_sixty_fourth = (3 * quarter_note_length / 32)
+    
+    @duration_table = {
+      whole => 'whole',
+      dotted_whole => 'dotted whole',
+      whole_triplet => 'whole triplet',
+      half => 'half',
+      dotted_half => 'dotted half',
+      half_three => 'half triplet',
+      quarter_note_length => 'quarter',
+      dotted_quarter => 'dotted quarter',
+      quarter_triplet => 'quarter triplet',
+      eight => 'eighth',
+      dotted_eight => 'dotted eighth',
+      eight_triplet => 'eighth triplet',
+      sixteenth => 'sixteenth',
+      dotted_sixteenth => 'dotted sixteenth',
+      sixteenth_triplet => 'sixteenth triplet',
+      thirty_second => 'thirtysecond',
+      dotted_thirty_second => 'dotted thirtysecond',
+      thirty_second_triplet => 'thirtysecond triplet',
+      sixty_fourth => 'sixtyfourth',
+      dotted_sixty_fourth => 'dotted sixtyfourth',
+      sixty_fourth_triplet => 'sixtyfourth triplet'
+    }
+  end
+  
+end
+
+# This class represents a state on the markov chain. This state
+# is built from a note and a duration string representation.
+class MidiElement
+  
+  attr_accessor :note, :duration
+  
+  # Initializes the midi element by a note string and a string representation of the duration.
+  def initialize(note, duration)
+    @note = note
+    @duration = duration
+  end
+  
+  # Overriding comparison to be used on "=="
+  def ==(comparison_object)
+    comparison_object.equal?(self) ||
+      (comparison_object.instance_of?(self.class) && 
+       @note == comparison_object.note &&
+       @duration == comparison_object.duration)
+  end
+  
+  # Overriding comparison to be used on hashing
+  def eql?(comparison_object)
+    self.class.equal?(comparison_object.class) &&
+      @note == comparison_object.note &&
+      @duration == comparison_object.duration
+  end
+  
+  def hash
+    @note.hash ^ @duration.hash
+  end
+  
+  def to_s
+    "[Note: #{@note} Duration: #{@duration}]"
+  end
+  
+end
+
+end

data/lib/musikov/markov_model.rb

@@ -0,0 +1,99 @@
+
+module Musikov
+
+# This class represents a generic markov chain. It holds
+# a hash of frequencies of subsequent states, for each state.
+class MarkovModel
+  
+  attr_reader :frequencies
+  
+  ###################
+  public
+  ###################
+  
+  # Initialize the hashes used to build the markov chain.
+  # Passes the initial array of values to be included in the model.
+  # * The "transitions" hash maps a state into another hash mapping the subsequent states to its number of subsequent occurrences
+  # * The "frequencies" hash maps a state into another hash mapping the subsequent states to a frequency indicating the probability of subsequent occurrences.
+  def initialize(value_chain = [])
+    @transitions = {}
+    @frequencies = {}
+    add_input(value_chain)
+  end
+  
+  # Generate a random sequence from a markov chain
+  # * The initial_value is a state where the random chain must start
+  # * The initial_value may be nil
+  # * The value_number indicates the number of elements on the result random sequence
+  def generate(initial_value, value_number)
+    generated_sequence = []
+    selected_value = initial_value
+    
+    until generated_sequence.count == value_number do
+      selected_value = pick_value(rand(0.1..1.0), selected_value)
+      generated_sequence << selected_value
+    end
+    
+    return generated_sequence
+  end
+  
+  # Passes the argument array of state values to be included in the model.
+  def add_input(value_chain = [])
+    prev_value = nil
+    
+    value_chain.each { |value|
+      add_value(prev_value, value)
+      prev_value = value
+    }
+    
+    compute_frequencies
+  end
+  
+  ###################
+  private
+  ###################
+  
+  # Add a state on the transitions hash
+  def add_value(prev_value, value) 
+    @transitions[prev_value] ||= Hash.new{0}
+    @transitions[prev_value][value] += 1
+  end
+  
+  # Pick a value on the frequencies hash based on a random number and the previous state
+  def pick_value(random_number, prev_value)
+	  next_value = @frequencies[prev_value]
+    if next_value.nil? then
+		  next_value = @frequencies[nil]
+	  end
+
+    succ_list =  next_value.sort_by{|key, value| value}
+    freq_counter = 0.0
+    
+    succ_list.each { |succ_value, freq|
+      freq_counter += freq
+      return succ_value if freq_counter >= random_number
+    }
+  end
+  
+  # Compute the frequencies hash based on the transistions hash
+  def compute_frequencies
+    @transitions.map { |value, transition_hash|
+      sum = 0.0
+      transition_hash.each { |succ_value, occurencies| 
+        sum += occurencies
+      }
+      
+      transition_hash.each { |succ_value, occurencies|
+        @frequencies[value] ||= Hash.new{0}
+        @frequencies[value][succ_value] = occurencies/sum 
+      }
+    }
+  end
+  
+  def to_s
+    return @frequencies
+  end
+  
+end
+
+end

data/lib/musikov/midi_parser.rb

@@ -0,0 +1,73 @@
+require 'midilib/sequence'
+require 'midilib/io/seqreader'
+
+module Musikov
+  
+class FileNotFoundError < StandardError ; end
+
+# This class is responsible for interacting with MidiLib in order
+# to read the input midi files.
+class MidiParser
+  
+  ####################
+  public
+  ####################
+  
+  # Initializes the parser using the file (or folder) path parameter
+  # * Parameter can be a single file path or a folder
+  def initialize(file_or_folder_paths = [])
+    @paths = []
+    @paths += file_or_folder_paths
+  end
+  
+  # Obtains the list of midi files to parse and call the Midilib parse routine
+  def parse
+    result = []
+    files = []
+    
+    @paths.each { |path|
+      begin
+        raise FileNotFoundError unless File.exists?(path)
+        
+        if File.directory?(path) then
+          files += Dir.glob("#{path}/**/*.mid")
+        else
+          files << path if File.extname(path) == ".mid"
+        end
+      rescue
+        puts "Not a valid file path : #{path} => #{$!}"
+      end
+    }
+    
+    
+    if files.empty? then
+      puts "No files were added."
+    else
+      files.each { |file_path|
+        result << read_midi(file_path)
+      }
+    end
+    
+    return result
+  end
+  
+  ####################
+  private
+  ####################
+  
+  # Call the Midilib's parse routine to read information from a midi file
+  def read_midi(file_path)
+    # Create a new, empty sequence.
+    seq = MIDI::Sequence.new()
+    
+    # Read the contents of a MIDI file into the sequence.
+    File.open(file_path, 'rb') { | file |
+        seq.read(file)
+    }
+    
+    return seq
+  end
+    
+end
+
+end

data/lib/musikov/midi_writer.rb

@@ -0,0 +1,67 @@
+require 'midilib/sequence'
+require 'midilib/consts'
+require 'midilib/io/seqwriter'
+
+module Musikov
+
+# This class is responsible for interacting with MidiLib in order
+# to write the output midi files.
+class MidiWriter
+  
+  ####################
+  public
+  ####################
+  
+  # Initializes the parser using the output path parameter
+  # * Parameter need to be a folder folder
+  def initialize(output_path = ".")
+    @path = output_path
+  end
+  
+  # Writes the output midi file from the generated sequence hash
+  def write(sequence_hash)
+    # Create a new, empty sequence.
+    seq = MIDI::Sequence.new()
+    
+    track = MIDI::Track.new(seq)
+    seq.tracks << track
+    track.events << MIDI::Tempo.new(MIDI::Tempo.bpm_to_mpq(120))
+    i = 0
+    
+    # Create a track to hold the notes. Add it to the sequence.
+    sequence_hash.each { |program_change, midi_elements|
+      track = MIDI::Track.new(seq)
+      seq.tracks << track
+      
+      instrument = MIDI::GM_PATCH_NAMES[program_change]
+    
+      # Give the track a name and an instrument name (optional).
+      track.instrument = instrument
+    
+      # Add a volume controller event (optional).
+      track.events << MIDI::Controller.new(i, MIDI::CC_VOLUME, 127)
+      track.events << MIDI::ProgramChange.new(i, program_change, 0)
+      midi_elements.each { |midi_element|
+        track.events << MIDI::NoteOn.new(i, midi_element.note ,127,0)
+        track.events << MIDI::NoteOff.new(i, midi_element.note ,127, seq.note_to_delta(midi_element.duration))
+      }
+
+      i += 1
+    }
+    
+    write_midi(seq)
+  end
+  
+  ####################
+  private
+  ####################
+  
+  # Call the Midilib's parse routine to read information from a midi file
+  def write_midi(seq)
+    # Writing output file
+    File.open("#{@path}/output.mid", 'wb') { | file | seq.write(file) }
+  end
+    
+end
+
+end

data/spec/markov_builder_spec.rb

@@ -0,0 +1,27 @@
+require 'rspec'
+require 'musikov/markov_builder'
+
+describe Musikov::MidiElement do
+  
+  it "should respect equals based on the 'note' and 'duration' attributes" do
+    midi1 = Musikov::MidiElement.new("silence", 64)
+    midi2 = Musikov::MidiElement.new("silence", 64)
+    
+    midi1.should == midi2
+  end
+  
+  it "should same hash if objects have the same attributes" do
+    midi1 = Musikov::MidiElement.new("silence", 64)
+    midi2 = Musikov::MidiElement.new("silence", 64)
+    
+    midi1.hash.should == midi2.hash 
+  end
+  
+  it "should respect eql? equality" do
+    midi1 = Musikov::MidiElement.new("silence", 64)
+    midi2 = Musikov::MidiElement.new("silence", 64)
+    
+    (midi1.eql? midi2).should == true
+  end
+
+end

data/spec/markov_model_spec.rb

@@ -0,0 +1,34 @@
+require 'rspec'
+require 'musikov/markov_model'
+
+describe Musikov::MarkovModel do
+  
+  it "should add values with its correspondent frequence" do
+    text = "The man is tall. The man is big."
+
+    mc = Musikov::MarkovModel.new(text.split)
+    mc.frequencies["is"].should == {"big." => 0.5, "tall." => 0.5}
+  end
+  
+  it "should pick word corresponding to random number" do
+    text = "The man is tall. The man is big."
+
+    # Obs: testing private method through "send"
+    mc = Musikov::MarkovModel.new(text.split)
+    wd = mc.send(:pick_value, 0.8, "is")
+    wd.should == "tall."
+  end
+  
+  it "should re-compute frequencies after inserting more input" do
+    text1 = "The man is tall. The man is big."
+    text2 = "The man is strange. The man is very strange."
+
+    mc = Musikov::MarkovModel.new()
+    mc.add_input(text1.split)
+    mc.frequencies["is"].should == {"big." => 0.5, "tall." => 0.5}
+    
+    mc.add_input(text2.split)
+    mc.frequencies["is"].should == {"big." => 0.25, "tall." => 0.25, "strange." => 0.25, "very" => 0.25}
+  end
+  
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: musikov
+version: !ruby/object:Gem::Version
+  version: '0.15'
+  prerelease: 
+platform: ruby
+authors:
+- Andre Fonseca
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: midilib
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Musikov - Random song generator based on Markov Chains
+email: andre.amorimfonseca@gmail.com
+executables:
+- musikov
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- LICENSE
+- README.md
+- bin/musikov
+- lib/musikov/markov_builder.rb
+- lib/musikov/markov_model.rb
+- lib/musikov/midi_parser.rb
+- lib/musikov/midi_writer.rb
+- lib/musikov.rb
+- spec/markov_model_spec.rb
+- spec/markov_builder_spec.rb
+homepage: https://github.com/andreAmorimF/musikov
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Musikov - Random song generator based on Markov Chains
+test_files: []