lydown 0.7.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2945708b90bba8a47e9c037ed6b58feee552c411
-  data.tar.gz: 3fab488b2070abaa55eccd5a2d1ee2af496419af
+  metadata.gz: 9597286c88009e270c73fae97a968f1d946c52e2
+  data.tar.gz: d360df9c114bfc5fefcaf600832e549c42997232
 SHA512:
-  metadata.gz: c9a16ab91b2118d2ceed5791caa10319fac63e38bd09da38e19fb57ba52ab5ad6b3db857c811211a0e8f5d167d0f0e5b841aee06f0bb607df4cdba0cbd794b97
-  data.tar.gz: 25df40e9a348873a1da26969c8f8275e7f806ff4f5386657c3a1eba4acdbd7d84f4c687eb5653867973dd656acf4b9eeb59a4ce9e9da9d73894d09a609ae7123
+  metadata.gz: 603853150a584ee4951388f1565bee07aac65e36639a703d10944de9b011f6530243a9f25fe2abe037f35ce84d33c3bc11a7139fbe7ea16144c4c49662a2dcb2
+  data.tar.gz: 04c071237d29bdaaa0fb78becd234ae5da75fc1321cafd0901fd879b472a09aaf01713c858b9a233a29243d4fa1b62b19cd1f768f85c261eadb6b84d855e2d2a

data/README.md

@@ -97,19 +97,7 @@ Notes can be repeated using the <code>@</code> placeholder:
 Chords are written using angled brackets, like in lilypond:
 
     (2<fd>4<ge>) => <f d>2( <g e>4)
-
-### Rests
-
-Normal rests are written [like in lilypond](http://www.lilypond.org/doc/v2.18/Documentation/notation/writing-rests#rests):
-
-    4ce2r => c4 e r2
-
-Full bar rests are [similar to lilypond](http://www.lilypond.org/doc/v2.18/Documentation/notation/writing-rests#full-measure-rests), except there's no need to enter the rest value (it is implicit in the time signature):
-
-    - time: 3/4
-    // 4 bar rest in the middle
-    2c4e R*4 2.g
-
+    
 ### Accidentals
 
 Accidentals can be entered using + and -
@@ -143,7 +131,18 @@ A ficta accidental (an non-original accidental that appears above the staff) can
 
 ### Octaves
 
-Like in lilypond's [relative mode](http://www.lilypond.org/doc/v2.18/Documentation/notation/writing-pitches#relative-octave-entry), lydown uses ' and , for moving between octaves. The starting point is always c (that is c°).
+In Lydown, the first note in the document carries an absolute octave marker, using the <code>'</code> and <code>,</code> signs:
+
+      c,,   // contrabass octave
+      c,    // great octave
+      c     // small octave
+      c'    // first octave (middle c)
+      c''   // second octave
+      c'''  // third octave
+      ...   // etc.
+
+For the following notes, the octave markers <code>'</code> and <code>,</code> are used for jumping between octaves, using the same rules as 
+ lilypond's [relative mode](http://www.lilypond.org/doc/v2.18/Documentation/notation/writing-pitches#relative-octave-entry):
 
 ### Barlines
 
@@ -156,6 +155,18 @@ When entering unmetered music, an invisible barline can be added in order to pro
     -time: unmetered
     cdef ?| gag
 
+### Rests
+
+Normal rests are written [like in lilypond](http://www.lilypond.org/doc/v2.18/Documentation/notation/writing-rests#rests):
+
+    4ce2r => c4 e r2
+
+Full bar rests are [similar to lilypond](http://www.lilypond.org/doc/v2.18/Documentation/notation/writing-rests#full-measure-rests), except there's no need to enter the rest value (it is implicit in the time signature):
+
+    - time: 3/4
+    // 4 bar rest in the middle
+    2c4e R*4 2.g
+
 ### Beams, slurs and ties
 
 Lydown uses automatic beaming as the default, except in the case of vocal parts (see [document settings](#settings)). Auto beaming can be

data/bin/lydown

@@ -1,126 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'rubygems'
-require 'lydown'
-require 'lydown/version'
 require 'lydown/cli'
-require 'optparse'
 
-trap("INT") {exit}
-trap("TERM") {exit}
-
-help = <<HELP
-Lydown is not lilypond
-HELP
-
-$options = {'format' => 'pdf'}.deep!
-opts = OptionParser.new do |opts|
-  opts.banner = help
-
-  opts.on("-v", "--version", "Display current version") do
-    puts "lydown " + Lydown::VERSION
-    exit 0
-  end
-  
-  opts.on("-p", "--parts PART", "Parts (comma-separated)") do |v|
-    $options[:parts] = v.split(',')
-  end
-  
-  opts.on("-m", "--mvts MVT", "Movements (comma-separated)") do |v|
-    $options[:movements] = v.split(',')
-  end
-  
-  opts.on("--no-score", "Do not generate secore") do
-    $options[:no_score] = true
-  end
-  
-  opts.on("-s", "--score", "Generate only score, no parts") do
-    $options[:score_only] = true
-  end
-  
-  opts.on("-V", "--vocal", "Generate only vocal score") do
-    $options[:vocal_only] = true
-  end
-  
-  opts.on("--ly", "Generate Lilypond file") do
-    $options[:format] = 'ly'
-  end
-  
-  opts.on("--pdf", "Generate PDF file") do
-    $options[:format] = 'pdf'
-  end
-
-  opts.on("--png", "Generate PNG file") do
-    $options[:format] = 'png'
-  end
-
-  opts.on("-M", "--midi", "Generate midi file") do
-    $options[:format] = 'midi'
-    $options[:score_only] = true # implied
-  end
-  
-  opts.on("-P", "--proof", "Start proofing mode") do
-    $options[:open_target] = true
-    $options[:proof_mode] = true
-  end
-  
-  opts.on("-O", "--open", "Open PDF/Midi file after processing") do
-    $options[:open_target] = true
-  end
-
-  opts.on("-o", "--output FILE", "Filename for output") do |v|
-    $options[:output_filename] = v
-  end
-
-  opts.on("-W", "--work", "Create new work") do
-    $options[:gen] = :work
-  end
-end
-
-opts.parse!
-
-if $options[:gen]
-  # Ripple.generate($options[:gen], ARGV)
-  exit
-end
-
-source = ''
-if ARGV[0] == '-'
-  # read source from stdin
-  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
-  filename = ARGV[0] || '.'
-  $options[:source_filename] = filename
-  if (filename !~ /\.ld$/) and File.file?(filename + ".ld")
-    filename += ".ld"
-  end
-  
-  unless $options[:output_filename]
-    if filename == '.'
-      $options[:output_filename] = File.basename(FileUtils.pwd)
-    else
-      $options[:output_filename] = (filename =~ /^(.+)\.ld$/) ? $1 : filename
-    end
-  end
-end
-
-if $options[:proof_mode]
-  Lydown::CLI::Proofing.start_proofing($options)
-else
-  # compile score
-  unless $options[:no_score] || $options[:parts]
-    Lydown::CLI::Compiler.process($options.merge(mode: :score, parts: nil))
-  end
-
-  # compile parts
-  unless $options[:score_only] || !$options[:parts]
-    parts = $options[:parts]
-    parts.each do |p|
-      Lydown::CLI::Compiler.process($options.merge(mode: :part, parts: p))
-    end
-  end
-end
+Lydown::CLI::Commands.start(ARGV)

data/lib/lydown.rb

@@ -1,5 +1,3 @@
-require 'rubygems'
-
 module Lydown; end
 
 require 'lydown/core_ext'
@@ -8,4 +6,6 @@ require 'lydown/parsing'
 require 'lydown/templates'
 require 'lydown/rendering'
 require 'lydown/lilypond'
-require 'lydown/work'
+require 'lydown/work_context'
+require 'lydown/work'
+require 'lydown/translation'

data/lib/lydown/cli.rb

@@ -3,6 +3,10 @@ module Lydown
   end
 end
 
+require 'lydown/cli/support'
 require 'lydown/cli/compiler'
 require 'lydown/cli/proofing'
 require 'lydown/cli/diff'
+require 'lydown/cli/translation'
+require 'lydown/cli/output'
+require 'lydown/cli/commands'

data/lib/lydown/cli/commands.rb

@@ -0,0 +1,98 @@
+require 'thor'
+
+module Lydown::CLI
+  class Commands < Thor
+    desc "version", "show Lydown version"
+    def version
+      require 'lydown/version'
+      
+      puts "Lydown version #{Lydown::VERSION}"
+      exit!(0)
+    end
+
+    desc "compile [PATH]", "compile the lydown source at PATH"
+    method_option :format, aliases: '-f', 
+      default: 'pdf', desc: 'Set output format (pdf/png/ly/midi)', 
+      enum: %w{pdf png ly midi}
+    method_option :png, type: :boolean, desc: 'Set PNG output format'
+    method_option :ly, type: :boolean, desc: 'Set Lilypond output format'
+    method_option :midi, type: :boolean, desc: 'Set MIDI output format'
+
+    method_option :parts, aliases: '-p',
+      desc: 'Compile only the specified parts (comma separated)'
+    method_option :movements, aliases: '-m',
+      desc: 'Compile only the specified movements (comma separated)'
+    method_option :score_only, type: :boolean, aliases: '-s',
+      desc: 'Compile score only'
+    method_option :parts_only, type: :boolean, aliases: '-n',
+      desc: 'Compile parts only'
+    method_option :output, aliases: '-o',
+      desc: 'Set output path'
+    method_option :open_target, type: :boolean, aliases: '-O',
+      desc: 'Open output file after compilation'
+    method_option :verbose, type: :boolean
+    def compile(*args)
+      require 'lydown'
+      
+      opts = Lydown::CLI::Support.copy_options(options)
+      opts[:path] = args.first || '.'
+      Lydown::CLI::Support.detect_filename(opts)
+      
+      # Set format based on direct flag
+      [:png, :ly, :midi].each {|f| opts[:format] = f.to_s if opts[f]}
+
+      opts[:parts] = opts[:parts].split(',') if opts[:parts]
+      opts[:movements] = opts[:movements].split(',') if opts[:movements]
+      
+      # compile score
+      unless opts[:parts_only] || opts[:parts]
+        Lydown::CLI::Compiler.process(opts.merge(mode: :score, parts: nil))
+      end
+
+      # compile parts
+      unless opts[:score_only] || !opts[:parts]
+        parts = opts[:parts]
+        parts.each do |p|
+          Lydown::CLI::Compiler.process(opts.merge(mode: :part, parts: p))
+        end
+      end
+    end
+  
+    desc "proof [PATH]", "start proofing mode on source at PATH"
+    method_option :format, aliases: '-f', 
+      default: 'pdf', desc: 'Set output format (pdf/png/ly)', 
+      enum: %w{pdf png ly}
+    def proof(*args)
+      require 'lydown'
+
+      opts = Lydown::CLI::Support.copy_options(options)
+      opts[:path] = args.first || '.'
+      opts[:proof_mode] = true
+      opts[:open_target] = true
+    
+      Lydown::CLI::Support.detect_filename(opts)
+      Lydown::CLI::Proofing.start_proofing(opts)
+    end
+    
+    desc "translate [PATH]", "translate source at PATH into lydown code"
+    def translate(*args)
+      require 'lydown'
+
+      opts = Lydown::CLI::Support.copy_options(options)
+      opts[:path] = args.first || '.'
+    
+      Lydown::CLI::Translation.process(opts)
+    end
+    
+    def method_missing(method, *args)
+      args = ["compile", method.to_s] + args
+      self.class.start(args)
+    end
+  
+    default_task :compile
+
+    # Allow default task with test as path (should we be doing this for other 
+    # Object instance methods?)
+    undef_method(:test)
+  end
+end

data/lib/lydown/cli/compiler.rb

@@ -1,5 +1,3 @@
-require 'lydown'
-
 module Lydown::CLI::Compiler
   class << self
     def output_filename(opts)
@@ -14,6 +12,7 @@ module Lydown::CLI::Compiler
     end
     
     def process(opts)
+      t1 = Time.now
       opts = opts.deep_clone
       # translate lydown code to lilypond code
       ly_code = ''
@@ -23,11 +22,11 @@ module Lydown::CLI::Compiler
         work = Lydown::Work.new(opts)
         ly_code = work.to_lilypond(opts)
       rescue LydownError => e
-        STDERR.puts e.message
-        STDERR.puts e.backtrace.join("\n")
+        $stderr.puts e.message
+        $stderr.puts e.backtrace.join("\n")
         exit 1
       rescue => e
-        STDERR.puts "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+        $stderr.puts "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
         exit 1
       end
       
@@ -42,28 +41,26 @@ module Lydown::CLI::Compiler
               f.write ly_code
             end
           rescue => e
-            STDERR.puts "#{e.class}: #{e.message}"
+            $stderr.puts "#{e.class}: #{e.message}"
           end
         end
       else
         compile(ly_code, opts)
       end
+      t2 = Time.now
+      $stderr.puts "Elapsed: #{'%.1f' % [t2-t1]}s"
     end
 
     def compile(ly_code, opts)
       opts = opts.deep_clone
       begin
-        STDERR.puts "Compiling => #{opts[:output_target]}"
-        t1 = Time.now
         Lydown::Lilypond.compile(ly_code, opts)
-        t2 = Time.now
-        STDERR.puts "Elapsed: #{t2-t1}s"
       rescue LydownError => e
-        STDERR.puts e.message
-        STDERR.puts e.backtrace.join("\n")
+        $stderr.puts e.message
+        $stderr.puts e.backtrace.join("\n")
       rescue => e
-        STDERR.puts "#{e.class}: #{e.message}"
-        STDERR.puts e.backtrace.join("\n")
+        $stderr.puts "#{e.class}: #{e.message}"
+        $stderr.puts e.backtrace.join("\n")
       end
 
       if opts[:open_target]

data/lib/lydown/cli/diff.rb

@@ -18,7 +18,7 @@ module Lydown::CLI::Diff
         set_cached_content(path, read_content(path)) rescue nil
         count += 1
       end
-      puts "Cached #{count} files."
+      $stderr.puts "Cached #{count} files."
     end
     
     def read_content(path)
@@ -47,8 +47,8 @@ module Lydown::CLI::Diff
       
       first..last
     rescue => e
-      STDERR << e.message
-      STDERR << e.backtrace.join("\n")
+      $stderr.puts e.message
+      $stderr.puts e.backtrace.join("\n")
       nil..nil
     end
   end

data/lib/lydown/cli/output.rb

@@ -0,0 +1,18 @@
+require 'ruby-progressbar'
+
+module Lydown::CLI
+  PROGRESS_FORMAT = '%t:%B:%p%%'
+  
+  # Simple wrapper around ProgressBar
+  def self.show_progress(title, total)
+    $progress_bar = ProgressBar.create(
+      title: title,
+      total: total,
+      format: PROGRESS_FORMAT,
+    )
+    yield $progress_bar
+  ensure
+    $progress_bar.stop
+    $progress_bar = nil
+  end
+end

data/lib/lydown/cli/proofing.rb

@@ -7,21 +7,23 @@ module Lydown::CLI::Proofing
       
       Lydown::CLI::Diff.fill_cache(source)
       
-      puts "Proof mode: #{source} -> #{opts[:output_filename]}"
+      $stderr.puts "Proof mode: #{source} -> #{opts[:output_filename]}"
       last_proof_path = nil
 
       watch_directory(source, opts)
     end
     
     def watch_directory(source, opts)
-      dw = DirectoryWatcher.new(File.expand_path(source))
+      dw = DirectoryWatcher.new(
+        File.expand_path(source),
+        glob: ["**/*.ld"],
+        pre_load: true
+      )
       dw.interval = 0.25
-      dw.glob = ["#{source}/**/*.ld"]
 
-      dw.reset(true)
       dw.add_observer do |*args|
         args.each do |e|
-          if e.type = :modified
+          if e.type == :modified
             path = File.expand_path(e.path)
             if path =~ /^#{File.expand_path(source)}\/(.+)/
               path = $1
@@ -85,7 +87,7 @@ module Lydown::CLI::Proofing
     def process(opts)
       if opts[:line_range] != (nil..nil)
         t = Time.now.strftime("%H:%M:%S")
-        puts "[#{t}] Changed: #{opts[:base_path]} (lines #{opts[:line_range].inspect})"
+        $stderr.puts "[#{t}] Changed: #{opts[:base_path]} (lines #{opts[:line_range].inspect})"
         Lydown::CLI::Compiler.process(opts)
       end
     end