lydown 0.7.2 → 0.9.0

data/lib/lydown/cli/support.rb

@@ -0,0 +1,34 @@
+module Lydown::CLI::Support
+  def self.copy_options(options)
+    opts = {}.deep!
+    
+    options.each {|k, v| opts[k.to_sym] = v}
+    opts
+  end
+  
+  def self.detect_filename(options)
+    source = ''
+    if options[:path] == '-'
+      # read source from stdin
+      options[:source] = STDIN.read
+  
+      # the output defaults to a file named lydown expect if the format is ly.
+      # In that case the output will be sent to STDOUT.
+      options[:output_filename] ||= 'lydown' unless options[:format] == 'ly'
+    else
+      options[:source_filename] = options[:path]
+      if (options[:path] !~ /\.ld$/) and File.file?(options[:path] + ".ld")
+        options[:path] += ".ld"
+      end
+  
+      unless options[:output_filename]
+        if options[:path] == '.'
+          options[:output_filename] = File.basename(FileUtils.pwd)
+        else
+          options[:output_filename] = (options[:path] =~ /^(.+)\.ld$/) ?
+            $1 : options[:path]
+        end
+      end
+    end
+  end
+end

data/lib/lydown/cli/translation.rb

@@ -0,0 +1,73 @@
+require 'yaml'
+
+module Lydown::CLI::Translation
+  class << self
+    def process(opts)
+      if File.directory?(opts[:path])
+        process_directory(opts[:path])
+      elsif File.file?(opts[:path])
+        process_file(opts[:path])
+      elsif File.file?(opts[:path] + '.rpl')
+        process_file(opts[:path] + '.rpl')
+      end
+    end
+    
+    def process_directory(path)
+      macros = load_macros(path)
+      Dir["#{path}/*"].entries.each do |entry|
+        if File.file?(entry) && (entry =~ /\.rpl$/)
+          process_file(entry)
+        elsif File.directory?(entry)
+          process_directory(entry)
+        end
+      end
+    end
+    
+    def process_file(path)
+      ext = File.extname(path)
+      base_path = ext == '.rpl' ? path.gsub(/#{ext}$/, '') : path
+      output_path = base_path + '.ld'
+      lyrics_path = base_path + '.lyr'
+      figures_path = base_path + '.fig'
+      
+      $stderr.puts "Translating #{path}..."
+      
+      code = {
+        path: path,
+        ripple: IO.read(path),
+        lyrics: File.file?(lyrics_path) && IO.read(lyrics_path),
+        figures: File.file?(figures_path) && IO.read(figures_path),
+        macros: macros_for_path(path)
+      }
+      
+      ld_code = Lydown::Translation.process(code)
+
+      File.open(output_path, 'w+') {|f| f.write(ld_code)}
+    end
+    
+    WORK_FILENAME = '_work.yml'
+    MOVEMENT_FILENAME = '_movement.yml'
+    
+    PATH_MACROS = {}
+    
+    def macros_for_path(path)
+      PATH_MACROS[path] ||= load_macros(path)
+    end
+    
+    def load_macros(path)
+      base_dir = File.directory?(path) ? path : File.dirname(path)
+      parent_dir = File.expand_path(File.join(base_dir, '..'))
+      
+      yml = 
+        (YAML.load_file(File.join(parent_dir, WORK_FILENAME)) rescue nil) || 
+        (YAML.load_file(File.join(base_dir, WORK_FILENAME)) rescue nil) ||
+        {}
+      macros = yml['macros'] || {}
+      
+      yml = 
+        (YAML.load_file(File.join(base_dir, MOVEMENT_FILENAME)) rescue nil) ||
+        {}
+      macros.merge(yml['macros'] || {})
+    end
+  end
+end

data/lib/lydown/core_ext.rb

@@ -62,7 +62,7 @@ class Hash
     if @deep && k.is_a?(String) && k =~ /\//
       lookup(k)
     elsif @deep && k.is_a?(Symbol)
-      old_get(k.to_s)
+      old_get(k) || old_get(k.to_s)
     else
       old_get(k)
     end

data/lib/lydown/lilypond.rb

@@ -1,6 +1,9 @@
 require 'lydown/errors'
+require 'lydown/cli/output'
+
 require 'tempfile'
 require 'fileutils'
+require 'open3'
 
 module Lydown
   module Lilypond
@@ -28,8 +31,9 @@ module Lydown
           copy_pages(tmp_target, target, ext)
         end
       rescue => e
-        puts e.message
-        p e.backtrace
+        $stderr.puts e.message
+        $stderr.puts e.backtrace.join("\n")
+        raise e
       end
       
       def copy_pages(source, target, ext)
@@ -46,25 +50,59 @@ module Lydown
       end
       
       def invoke(source, opts = {})
+        format = opts[:format]
+        format = nil if format == 'midi'
+        
         # Run lilypond, pipe source into its STDIN, and capture its STDERR
-        cmd = 'lilypond -lERROR '
+        cmd = 'lilypond '
         cmd << "-o #{opts[:output_filename]} "
         cmd << "-dno-point-and-click "
-        cmd << "--#{opts[:format]} " if opts[:format]
-        cmd << '-s - 2>&1'
+        cmd << "--#{opts[:format]} " if format
+        cmd << ' - '
         
         err_info = ''
-        IO.popen(cmd, 'r+') do |f|
-          f.puts source
-          f.close_write
-          err_info = f.read
-          f.close
+        success = false
+        Open3.popen2e(cmd) do |input, output, wait_thr|
+          input.puts source
+          input.close_write
+          err_info = read_lilypond_progress(output, opts)
+          output.close
+          success = wait_thr.value == 0
         end
-        unless $?.success?
+        unless success
           err_info = err_info.lines[0, 3].join
           raise LydownError, "Lilypond compilation failed:\n#{err_info}"
         end
       end
+      
+      LILYPOND_STATUS_LINES = %w{
+        Processing
+        Parsing
+        Interpreting
+        Preprocessing
+        Finding
+        Fitting
+        Drawing
+        Layout
+        Converting
+        Success:
+      }
+      STATUS_TOTAL = LILYPOND_STATUS_LINES.size
+      
+      def read_lilypond_progress(f, opts)
+        info = ''
+        Lydown::CLI::show_progress('Compile', STATUS_TOTAL) do |bar|
+          while !f.eof?
+            line = f.gets
+            info += line
+            if line =~ /^([^\s]+)/
+              idx = LILYPOND_STATUS_LINES.index($1)
+              bar.progress = idx + 1 if idx
+            end
+          end
+        end
+        info
+      end
     end
   end
 end

data/lib/lydown/parsing.rb

@@ -4,26 +4,57 @@ require 'treetop'
 require 'lydown/parsing/nodes'
 require 'lydown/parsing/lydown.treetop'
 
-# Treetop.load 'lydown/parsing/lydown'
-
 class LydownParser
   def self.parse(source, opts = {})
-    parser = self.new
+    if opts[:no_progress]
+      do_parse(source, opts)
+    else
+      Lydown::CLI.show_progress('Parse', source.length * 2) do |bar|
+        stream = do_parse(source, opts)
+        bar.finish
+        stream
+      end
+    end
+  end
+  
+  def self.do_parse(source, opts)
+    parser, ast = self.new
     ast = parser.parse(source)
+
     unless ast
       error_msg = format_parser_error(source, parser, opts)
-      STDERR.puts error_msg
+      $stderr.puts error_msg
       raise LydownError, error_msg
     else
       stream = []
+      ast.to_stream(stream, opts.merge(progress_base: source.length))
       # insert source ref event into stream if we have a filename ref
-      stream << {type: :source_ref}.merge(opts) if opts[:filename]
+      if opts[:filename] && !stream.empty?
+        stream.unshift({type: :source_ref}.merge(opts))
+      end
+      stream
+    end
+  end
+  
+  def self.parse_macro_group(source, opts)
+    parser, ast = self.new, ast = nil
+    old_bar, $progress_bar = $progress_bar, nil
+    ast = parser.parse(source)
+    unless ast
+      error_msg = format_parser_error(source, parser, opts)
+      $stderr.puts error_msg
+      raise LydownError, error_msg
+    else
+      stream = []
       ast.to_stream(stream, opts)
+      stream
     end
+  ensure
+    $progress_bar = old_bar
   end
 
   def self.format_parser_error(source, parser, opts)
-    msg = opts[:source_filename] ? "#{opts[:source_filename]}: " : ""
+    msg = opts[:filename] ? "#{opts[:filename]}: " : ""
     if opts[:nice_error]
       msg << "Unexpected character at line #{parser.failure_line} column #{parser.failure_column}:\n"
     else

data/lib/lydown/parsing/nodes.rb

@@ -1,5 +1,5 @@
 module Lydown::Parsing
-  module Root
+  module RootMethods
     def _to_stream(element, stream, opts)
       if element.elements
         element.elements.each do |e|
@@ -17,9 +17,9 @@ module Lydown::Parsing
     end
     
     def event_hash(stream, opts, hash = {})
-      if source = opts[:source]
+      if opts[:proof_mode] && (source = opts[:source])
         last = stream.last
-        if last && last[:type] == :source_ref && last[:line]
+        if last && (last[:type] == :source_ref) && last[:line]
           line, column = last[:line], last[:column]
         else
           line, column = source.find_line_and_column(interval.first)
@@ -34,18 +34,34 @@ module Lydown::Parsing
       else
         hash
       end
+    ensure
+      if $progress_bar
+        $progress_bar.progress = (opts[:progress_base] || 0) + interval.end
+      end
+    end
+    
+    def add_event(stream, opts, type)
+      stream << event_hash(stream, opts, {type: type})
+    end
+  end
+  
+  class Root < Treetop::Runtime::SyntaxNode
+    include RootMethods
+    def initialize(*args)
+      super
+      if $progress_bar
+        $progress_bar.progress = interval.end
+      end
     end
   end
 
-  module CommentContent
+  class CommentContent < Root
     def to_stream(stream, opts)
       stream << {type: :comment, content: text_value.strip}
     end
   end
 
-  module Setting
-    include Root
-
+  class Setting < Root
     def to_stream(stream, opts)
       level = (text_value =~ /^([\s]+)/) ? ($1.length / 2) : 0
       @setting = event_hash(stream, opts, {
@@ -76,9 +92,7 @@ module Lydown::Parsing
     end
   end
 
-  module DurationValue
-    include Root
-    
+  class DurationValue < Root
     def to_stream(stream, opts)
       stream << event_hash(stream, opts, {
         type: :duration, value: text_value
@@ -86,9 +100,7 @@ module Lydown::Parsing
     end
   end
 
-  module TupletValue
-    include Root
-    
+  class TupletValue < Root
     def to_stream(stream, opts)
       if text_value =~ /^(\d+)%((\d+)\/(\d+))?$/
         value, fraction, group_length = $1, $2, $4
@@ -107,9 +119,7 @@ module Lydown::Parsing
     end
   end
 
-  module GraceDuration
-    include Root
-    
+  class GraceDuration < Root
     GRACE_KIND = {
       nil => :grace,
       '/' => :acciaccatura,
@@ -125,9 +135,7 @@ module Lydown::Parsing
     end
   end
 
-  module Note
-    include Root
-
+  class Note < Root
     def to_stream(stream, opts)
       note = event_hash(stream, opts, {
         type: :note, raw: text_value
@@ -165,9 +173,7 @@ module Lydown::Parsing
     end
   end
   
-  module Chord
-    include Root
-    
+  class Chord < Root
     def to_stream(stream, opts)
       chord = event_hash(stream, opts, {
         type: :chord, notes: []
@@ -184,57 +190,55 @@ module Lydown::Parsing
     end
   end
 
-  module StandAloneFigures
-    include Root
-
+  class StandAloneFigures < Root
     def to_stream(stream, opts)
-      note = {type: :stand_alone_figures}
+      note = event_hash(stream, opts, {
+        type: :stand_alone_figures
+      })
       _to_stream(self, note, opts)
       stream << note
     end
   end
 
   module Phrasing
-    module BeamOpen
+    class BeamOpen < Root
       def to_stream(stream, opts)
-        stream << {type: :beam_open}
+        add_event(stream, opts, :beam_open)
       end
     end
 
-    module BeamClose
+    class BeamClose < Root
       def to_stream(stream, opts)
-        stream << {type: :beam_close}
+        add_event(stream, opts, :beam_close)
       end
     end
 
-    module SlurOpen
+    class SlurOpen < Root
       def to_stream(stream, opts)
-        stream << {type: :slur_open}
+        add_event(stream, opts, :slur_open)
       end
     end
 
-    module SlurClose
+    class SlurClose < Root
       def to_stream(stream, opts)
-        stream << {type: :slur_close}
+        add_event(stream, opts, :slur_close)
       end
     end
   end
 
-  module Tie
+  class Tie < Root
     def to_stream(stream, opts)
-      stream << {type: :tie}
+      stream << event_hash(stream, opts, {type: :tie})
     end
   end
 
-  module ShortTie
+  class ShortTie < Root
     def to_stream(stream, opts)
-      stream << {type: :short_tie}
+      stream << event_hash(stream, opts, {type: :short_tie})
     end
   end
 
-  module Rest
-    include Root
-    
+  class Rest < Root
     def to_stream(stream, opts)
       rest = event_hash(stream, opts, {
         type: :rest, raw: text_value, head: text_value[0]
@@ -249,9 +253,7 @@ module Lydown::Parsing
     end
   end
 
-  module Silence
-    include Root
-    
+  class Silence < Root
     def to_stream(stream, opts)
       stream << event_hash(stream, opts, {
         type: :silence, raw: text_value, head: text_value[0]
@@ -260,8 +262,7 @@ module Lydown::Parsing
   end
 
   module DurationMacroExpression
-    include Root
-    
+    include RootMethods
     def to_stream(stream, opts)
       stream << event_hash(stream, opts, {
         type: :duration_macro, macro: text_value
@@ -269,8 +270,7 @@ module Lydown::Parsing
     end
   end
 
-  module Lyrics
-    include Root
+  class Lyrics < Root
     def to_stream(stream, opts)
       o = {type: :lyrics}
       _to_stream(self, o, opts)
@@ -304,7 +304,7 @@ module Lydown::Parsing
     end
   end
   
-  module StreamIndex
+  class StreamIndex < Root
     def to_stream(o, opts)
       idx = (text_value =~ /\(([\d]+)\)/) && $1.to_i
       if idx.nil?
@@ -315,14 +315,16 @@ module Lydown::Parsing
   end
 
   module Barline
+    include RootMethods
     def to_stream(stream, opts)
-      stream << {type: :barline, barline: text_value}
+      stream << event_hash(stream, opts, {
+        type: :barline, 
+        barline: text_value
+      })
     end
   end
   
-  module Command
-    include Root
-    
+  class Command < Root
     def to_stream(stream, opts)
       cmd = event_hash(stream, opts, {
         type: :command, raw: text_value
@@ -361,15 +363,14 @@ module Lydown::Parsing
     end
   end
   
-  module VoiceSelector
+  class VoiceSelector < Root
     def to_stream(stream, opts)
       voice = (text_value =~ /^([1234])/) && $1.to_i
       stream << {type: :voice_select, voice: voice}
     end
   end
   
-  module SourceRef
-    include Root
+  class SourceRef < Root
     def to_stream(stream, opts)
       ref = {type: :source_ref, raw: text_value}
       _to_stream(self, ref, opts)