musicality 0.10.1 → 0.11.0

data/lib/musicality/project/auditions_task.rb

@@ -0,0 +1,28 @@
+module Musicality
+module Tasks
+
+class Auditions < Rake::TaskLib
+  attr_reader :auditions_dirs
+
+  TEMPO_SAMPLE_RATE = 200
+  AUDITIONS_DIR = "auditions"
+  AUDITIONS_EXT = ".auditions"
+
+  def initialize yaml_filelist, audio_format = nil
+    @auditions_dirs = yaml_filelist.pathmap("%d/#{AUDITIONS_DIR}")
+    @auditions_dirs.each { |auditions_dir| directory auditions_dir }
+
+    format_flag = audio_format.nil? ? "" : "--format=#{audio_format}"
+    subtask = audio_format.nil? ? "" : ":#{audio_format}"
+
+    task "auditions#{subtask}" => yaml_filelist + @auditions_dirs do
+      yaml_filelist.each_with_index do |yaml_fname,i|
+        auditions_dir = @auditions_dirs[i]
+        `auditions #{yaml_fname} --outdir="#{auditions_dir}" #{format_flag}`
+      end
+    end
+  end
+end
+
+end
+end

data/lib/musicality/project/create_tasks.rb

@@ -1,31 +1,37 @@
 module Musicality
+  class Project
 
-class Project
   def self.create_tasks config
-    score_files = Rake::FileList[config[:scores]]
-    
+    score_files = Rake::FileList[File.join(SCORES_DIR,"*"+SCORE_EXT)]
+
     yaml_task = Tasks::FileRaker::YAML.new(score_files)
-    
+
     tempo_sample_rate = config[:tempo_sample_rate]
     lilypond_task = Tasks::FileRaker::LilyPond.new(yaml_task.files)
     midi_task = Tasks::FileRaker::MIDI.new(yaml_task.files, tempo_sample_rate)
     supercollider_task = Tasks::FileRaker::SuperCollider.new(yaml_task.files, tempo_sample_rate)
-    
+
     sample_rate, sample_format = config[:audio_sample_rate], config[:audio_sample_format]
     wav_task = Tasks::FileRaker::Audio.new(supercollider_task.files, :wav, sample_rate, sample_format)
     aiff_task = Tasks::FileRaker::Audio.new(supercollider_task.files, :aiff, sample_rate, sample_format)
     flac_task = Tasks::FileRaker::Audio.new(supercollider_task.files, :flac, sample_rate, sample_format)
-    
+
     pdf_task = Tasks::FileRaker::Visual.new(lilypond_task.files, :pdf)
     png_task = Tasks::FileRaker::Visual.new(lilypond_task.files, :png)
     ps_task = Tasks::FileRaker::Visual.new(lilypond_task.files, :ps)
 
+    auditions_default_task = Tasks::Auditions.new yaml_task.files
+    auditions_flac_task = Tasks::Auditions.new yaml_task.files, "flac"
+    auditions_wav_task = Tasks::Auditions.new yaml_task.files, "wav"
+    auditions_aiff_task = Tasks::Auditions.new yaml_task.files, "aiff"
+
     outfiles = (
-        yaml_task.files + lilypond_task.files + midi_task.files + supercollider_task.files + 
-        pdf_task.files + png_task.files + ps_task.files + 
+        yaml_task.files + lilypond_task.files + midi_task.files + supercollider_task.files +
+        pdf_task.files + png_task.files + ps_task.files +
         wav_task.files + aiff_task.files + flac_task.files
     ).select {|fname| File.exists? fname }
-    clean_task = Tasks::FileCleaner.new(outfiles)  
+    outdirs = auditions_default_task.auditions_dirs + yaml_task.subdirs + [Project::OUT_DIR]
+    clean_task = Tasks::FileCleaner.new(outfiles, outdirs)
   end
 end
 

data/lib/musicality/project/file_cleaner.rb

@@ -1,19 +1,36 @@
+require 'fileutils'
+
 module Musicality
 module Tasks
 
 class FileCleaner < Rake::TaskLib
-  def initialize outfiles
+  def initialize files, dirs
     task :clean do
-      if outfiles.any?
-        puts "Deleting output files:"
-        outfiles.each do |fname|
+      if files.any?
+        puts "Deleting files:"
+        files.each do |fname|
           puts " " + fname
           File.delete fname
         end
       end
+
+      existing_dirs = dirs.select {|dir| Dir.exist?(dir) }
+
+      if existing_dirs.any?
+        puts "Deleting dirs:"
+        existing_dirs.each do |dirname|
+          puts " " + dirname
+          begin
+            FileUtils::rm Dir.glob(File.join(dirname, "*"))
+            FileUtils::rmdir dirname
+          rescue => e
+            puts "Error while trying to delete #{dirname}: #{e}"
+          end
+        end
+      end
     end
   end
 end
 
 end
-end
+end

data/lib/musicality/project/file_raker.rb

@@ -2,26 +2,34 @@ module Musicality
 module Tasks
 
 class FileRaker < Rake::TaskLib
-  attr_reader :files, :task_name, :file_ext
-  
+  attr_reader :files, :task_name, :file_ext, :subdirs
+
   def initialize parent_filelist, task_name, file_ext, &rule_block
     raise ArgumentError, "parent filelist is empty" if parent_filelist.empty?
     raise ArgumentError, "no rule block given" unless block_given?
-    
-    @task_name, @file_ext = task_name, file_ext
-    @files = parent_filelist.ext(file_ext)
-    
-    task task_name => @files
-    
+
     parent_exts = parent_filelist.map {|str| File.extname(str) }.uniq
     raise ArgumentError, "multiple file extensions in parent filelist: #{parent_filelist}" unless parent_exts.one?
-    parent_ext = parent_exts.first
-    
-    rule file_ext => parent_ext do |t|
+
+    @task_name, @file_ext = task_name, file_ext
+    @subdirs = parent_filelist.pathmap("#{Project::OUT_DIR}/%n")
+    @files = parent_filelist.pathmap("#{Project::OUT_DIR}/%n/%n#{file_ext}")
+
+    directory Project::OUT_DIR
+    @subdirs.each { |subdir| directory subdir }
+    task task_name => [Project::OUT_DIR] + @subdirs + @files
+
+    find_parent_file = lambda do |f|
+      parent_filelist.detect do |f2|
+        File.basename(f2.ext("")) == File.basename(f.ext(""))
+      end
+    end
+
+    rule file_ext => find_parent_file do |t|
       rule_block.call(t)
     end
   end
-  
+
   class YAML < FileRaker
     def initialize score_files
       super(score_files, :yaml, ".yml") do |t|
@@ -31,7 +39,7 @@ class FileRaker < Rake::TaskLib
       end
     end
   end
-  
+
   class LilyPond < FileRaker
     def initialize yaml_files
       super(yaml_files, :lilypond, ".ly") do |t|
@@ -39,7 +47,7 @@ class FileRaker < Rake::TaskLib
       end
     end
   end
-  
+
   class MIDI < FileRaker
     def initialize yaml_files, tempo_sample_rate
       super(yaml_files, :midi, ".mid") do |t|
@@ -47,7 +55,7 @@ class FileRaker < Rake::TaskLib
       end
     end
   end
-  
+
   class SuperCollider < FileRaker
     def initialize yaml_files, tempo_sample_rate
       super(yaml_files, :supercollider, ".osc") do |t|
@@ -55,7 +63,7 @@ class FileRaker < Rake::TaskLib
       end
     end
   end
-  
+
   class Audio < FileRaker
     def check_sample_format audio_file_type, sample_format
       combination_okay = case audio_file_type
@@ -64,7 +72,7 @@ class FileRaker < Rake::TaskLib
       when :flac
         !["int32","float","mulaw","alaw"].include?(sample_format)
       else
-        true  
+        true
       end
 
       unless combination_okay
@@ -78,7 +86,7 @@ class FileRaker < Rake::TaskLib
 
         osc_fpath = t.sources[0]
         out_fpath = File.join(File.dirname(osc_fpath), File.basename(osc_fpath, File.extname(osc_fpath)) + ".#{audio_file_type}")
-        
+
         cmd_line = "scsynth -N \"#{osc_fpath}\" _ \"#{out_fpath}\" #{sample_rate} #{audio_file_type} #{sample_format}"
         IO.popen(cmd_line) do |pipe|
           while response = pipe.gets
@@ -93,13 +101,13 @@ class FileRaker < Rake::TaskLib
       end
     end
   end
-  
+
   class Visual < FileRaker
     def initialize lilypond_files, visual_file_type
       super(lilypond_files, visual_file_type, ".#{visual_file_type}") do |t|
         ly_fpath = t.sources[0]
         out_dir = File.dirname(ly_fpath)
-        
+
         sh "lilypond --output=\"#{out_dir}\" \"#{ly_fpath}\" --#{visual_file_type}"
       end
     end
@@ -107,4 +115,4 @@ class FileRaker < Rake::TaskLib
 end
 
 end
-end
+end

data/lib/musicality/project/project.rb

@@ -1,25 +1,71 @@
 module Musicality
 
 class Project
+  CONFIG_FILE_NAME = "config.yml"
+  SCORES_DIR = "scores"
+  SCORE_EXT = ".score"
+  OUT_DIR = "output"
+  SAMPLE_FORMATS = ["int8", "int16", "int24", "int32", "mulaw", "alaw", "float"]
+  DEFAULT_CONFIG = {
+    :tempo_sample_rate => 200,
+    :audio_sample_rate => 44100,
+    :audio_sample_format => "int16"
+  }
+  GEM_MUSICALITY = "gem 'musicality', '~> #{VERSION}'"
   USEFUL_MODULES = ['Musicality','Pitches','Meters','Keys','Articulations','Dynamics']
 
-  attr_reader :dest_dir
+  class ConfigError < RuntimeError
+  end
+
   def initialize dest_dir
-    @dest_dir = dest_dir
+    Project.create_project_dir_if_needed(dest_dir)
+    Project.create_scores_dir_if_needed(dest_dir)
+    Project.update(dest_dir)
+  end
+
+  def self.update dest_dir
+    if File.exists?(gemfile_path(dest_dir))
+      puts "Updating Gemfile"
+      update_gemfile(dest_dir)
+    else
+      puts "Creating Gemfile"
+      create_gemfile(dest_dir)
+    end
+
+    if File.exists?(rakefile_path(dest_dir))
+      puts "Updating Rakefile"
+      update_rakefile(dest_dir)
+    else
+      puts "Creating Rakefile"
+      create_rakefile(dest_dir)
+    end
 
-    create_project_dir
-    create_gemfile
-    create_rakefile
-    create_config
-    create_scores_dir
+    if File.exists?(config_path(dest_dir))
+      puts "Updating config.yml"
+      update_config(dest_dir)
+    else
+      puts "Creating config.yml"
+      create_config(dest_dir)
+    end
   end
 
-  def create_project_dir
-    if Dir.exists? dest_dir
-      unless Dir.glob(File.join(dest_dir,"*")).empty?
-        raise ArgumentError, "existing directory #{dest_dir} is not empty."
-      end
+  def self.config_path(dest_dir)
+    File.join(dest_dir,"config.yml")
+  end
+
+  def self.gemfile_path(dest_dir)
+    File.join(dest_dir,"Gemfile")
+  end
+
+  def self.rakefile_path(dest_dir)
+    File.join(dest_dir,"Rakefile")
+  end
+
+  def self.create_project_dir_if_needed(dest_dir)
+    if Dir.exists?(dest_dir)
+      puts "Project directory already exists"
     else
+      puts "Creating project directory #{dest_dir}"
       Dir.mkdir(dest_dir)
       unless Dir.exists?(dest_dir)
         raise "directory #{dest_dir} could not be created"
@@ -27,38 +73,178 @@ class Project
     end
   end
 
-  def create_gemfile
+  def self.create_scores_dir_if_needed(dest_dir, scores_dir = Project::SCORES_DIR)
+    scores_dir = File.join(dest_dir, scores_dir)
+    if Dir.exists? scores_dir
+      puts "Scores directory already exists"
+    else
+      puts "Creating scores directory #{scores_dir}"
+      Dir.mkdir(scores_dir)
+      unless Dir.exists?(scores_dir)
+        raise "directory #{scores_dir} could not be created"
+      end
+    end
+  end
+
+  #
+  # Gemfile
+  #
+
+  def self.create_gemfile(dest_dir)
     gemfile_path = File.join(dest_dir,"Gemfile")
-    File.open(gemfile_path,"w") do |f|
-      f.puts("source :rubygems")
-      f.puts("gem 'musicality', '~> #{VERSION}'")
+    File.new(gemfile_path(dest_dir),"w")
+    update_gemfile(dest_dir)
+  end
+
+  def self.update_gemfile(dest_dir)
+    pre_lines = []
+    lines = File.readlines(gemfile_path(dest_dir)).map {|l| l.chomp }
+
+    if line = lines.find {|x| x =~ /source/ }
+      delete_empty_lines_around lines, line
+      pre_lines.push lines.delete(line)
+    else
+      pre_lines.push("source :rubygems")
+    end
+
+    if line = lines.find {|x| x =~ /gem/ && x =~ /musicality/ }
+      delete_empty_lines_around lines, line
+      lines.delete(line)
+    end
+    pre_lines.push GEM_MUSICALITY
+
+    File.open(gemfile_path(dest_dir),"w") do |f|
+      f.puts pre_lines
+      if lines.any?
+        f.puts [""] + lines
+      end
     end
   end
 
-  def create_rakefile
+  #
+  # Rakefile
+  #
+
+  def self.create_rakefile(dest_dir)
     rakefile_path = File.join(dest_dir,"Rakefile")
-    File.open(rakefile_path,"w") do |f|
-      f.puts("require 'musicality'")
-      USEFUL_MODULES.each do |module_name|
-        f.puts("include #{module_name}")
+    File.new(rakefile_path(dest_dir),"w")
+    update_rakefile(dest_dir)
+  end
+
+  def self.update_rakefile(dest_dir)
+    pre_lines = []
+    lines = File.readlines(rakefile_path(dest_dir)).map {|l| l.chomp }
+
+    if line = lines.find {|x| x =~ /^[\s]*require[\s]+[\'\"]musicality[\'\"]/}
+      delete_empty_lines_around lines, line
+      pre_lines.push lines.delete(line)
+    else
+      pre_lines.push "require 'musicality'"
+    end
+    pre_lines.push ""
+
+    USEFUL_MODULES.each do |module_name|
+      if line = lines.find {|x| x =~ /^[\s]*include[\s]+#{module_name}/}
+        delete_empty_lines_around lines, line
+        pre_lines.push lines.delete(line)
+      else
+        pre_lines.push "include #{module_name}"
+      end
+    end
+
+    pre_lines.push ""
+    if line = lines.find {|x| x =~ /Project\.load_config/ }
+      delete_empty_lines_around lines, line
+      pre_lines.push lines.delete(line)
+    else
+      pre_lines.push "config = Project.load_config(File.dirname(__FILE__))"
+    end
+
+    if line = lines.find {|x| x =~ /Project\.create_tasks/ }
+      delete_empty_lines_around lines, line
+      pre_lines.push lines.delete(line)
+    else
+      pre_lines.push "Project.create_tasks(config)"
+    end
+
+    File.open(rakefile_path(dest_dir),"w") do |f|
+      f.puts pre_lines
+      if lines.any?
+        f.puts [""] + lines
       end
-      f.puts
-      f.puts("config = Project.load_config(File.dirname(__FILE__))")
-      f.puts("Project.create_tasks(config)")
     end
   end
 
-  def create_config
-    config_path = File.join(dest_dir, Project::CONFIG_FILE_NAME)
-    File.open(config_path,"w") do |f|
-      f.write(Project::DEFAULT_CONFIG.to_yaml)
+  #
+  # config.yml
+  #
+
+  def self.check_config config
+    config.each do |k,v|
+      case k
+      when :audio_sample_format
+        raise ConfigError, "#{k} => #{v} is not allowed" unless SAMPLE_FORMATS.include?(v)
+      when :tempo_sample_rate, :audio_sample_rate
+        raise ConfigError, "#{k} => #{v} is not positive" unless v > 0
+      end
     end
   end
 
-  def create_scores_dir
-    scores_dir = File.join(dest_dir, Project::BASE_SCORES_DIR)
-    Dir.mkdir(scores_dir)
+  def self.load_config project_root_dir
+    globabl_config_path = File.join(project_root_dir,CONFIG_FILE_NAME)
+
+    config = if File.exists? globabl_config_path
+      global_config = YAML.load(File.read(globabl_config_path))
+      DEFAULT_CONFIG.merge global_config
+    else
+      DEFAULT_CONFIG
+    end
+
+    # overrides from ENV
+    config.keys.each do |k|
+      k_str = k.to_s
+      if ENV.has_key? k_str
+        case k
+        when :tempo_sample_rate, :audio_sample_rate
+          config[k] = ENV[k_str].to_i
+        else
+          config[k] = ENV[k_str]
+        end
+      end
+    end
+
+    check_config config
+    return config
+  end
+
+  def self.create_config(dest_dir, config = Project::DEFAULT_CONFIG)
+    File.open(config_path(dest_dir),"w") do |f|
+      f.write(config.to_yaml)
+    end
+  end
+
+  def self.update_config(dest_dir)
+    config = Project.load_config(dest_dir)
+    config = Project::DEFAULT_CONFIG.merge(config)
+    create_config(dest_dir, config)
+  end
+
+  private
+
+  def self.delete_empty_lines_around lines, line
+    # delete lines before
+    i = lines.index(line)-1
+    while (i >= 0) && lines[i].empty?
+      lines.delete_at i
+      i -= 1
+    end
+
+    # delete lines after
+    i = lines.index(line)+1
+    while (i < lines.size) && lines[i].empty?
+      lines.delete_at i
+    end
   end
 end
 
-end
+end