lydown 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8f9e00d9938576429da9646dc782f2451c66afa9
-  data.tar.gz: 3fe22010c7e1928c74a5278eb659dc78922a53a8
+  metadata.gz: 2945708b90bba8a47e9c037ed6b58feee552c411
+  data.tar.gz: 3fab488b2070abaa55eccd5a2d1ee2af496419af
 SHA512:
-  metadata.gz: f18283718262a5404cb6e78ba0c155c3c0f750eaf3ddf47b3f5e6b460836980fb9019e2146bb093aa662e1da25625880fb935479e9766a47f565dd4107300516
-  data.tar.gz: 86b12d5d519691dc54f18fcfd061eb2d26a1d403780b3e8b5d800e32278bb78250841c818f1a76d7353fd5deffc99642d2eecf960c756205b06c7389a2e72650
+  metadata.gz: c9a16ab91b2118d2ceed5791caa10319fac63e38bd09da38e19fb57ba52ab5ad6b3db857c811211a0e8f5d167d0f0e5b841aee06f0bb607df4cdba0cbd794b97
+  data.tar.gz: 25df40e9a348873a1da26969c8f8275e7f806ff4f5386657c3a1eba4acdbd7d84f4c687eb5653867973dd656acf4b9eeb59a4ce9e9da9d73894d09a609ae7123

data/lib/lydown/cli/compiler.rb

@@ -72,7 +72,8 @@ module Lydown::CLI::Compiler
         unless File.file?(filename)
           filename = "#{opts[:output_target]}-page1.#{opts[:format]}"
         end
-        
+
+        # Mac OSX specific probably
         system("open #{filename}")
       end
     end

data/lib/lydown/cli/diff.rb

@@ -42,6 +42,9 @@ module Lydown::CLI::Diff
       
       set_cached_content(path, new_version)
       
+      first += 1 if first
+      last += 1 if last
+      
       first..last
     rescue => e
       STDERR << e.message

data/lib/lydown/cli/proofing.rb

@@ -20,16 +20,18 @@ module Lydown::CLI::Proofing
 
       dw.reset(true)
       dw.add_observer do |*args|
-        t = Time.now.strftime("%Y-%m-%d %H:%M:%S")
         args.each do |e|
           if e.type = :modified
             path = File.expand_path(e.path)
             if path =~ /^#{File.expand_path(source)}\/(.+)/
               path = $1
             end
-            puts "[#{t}] Changed: #{path}"
             last_proof_path = e.path unless File.basename(e.path) == 'movement.ld'
-            process(opts.deep_merge opts_for_path(last_proof_path, opts)) if last_proof_path
+            if last_proof_path
+              file_opts = opts.deep_merge opts_for_path(last_proof_path, opts)
+              file_opts[:base_path] = path
+              process(file_opts)
+            end
           end
         end
       end
@@ -44,12 +46,6 @@ module Lydown::CLI::Proofing
     def globs(path)
       Dir.chdir(path) do
         dirs = Dir['*'].select { |x| File.directory?(x) }
-        # exclude _ly, _pdf, _midi dirs
-        # ['ly_dir', 'pdf_dir', 'midi_dir'].map {|d| $config[d]}.each do |d|
-        #   if d =~ /^\.\/(.*)/
-        #     dirs -= [$1]
-        #   end
-        # end
       end
     
       dirs = dirs.map { |x| "#{x}/**/*" }
@@ -87,9 +83,9 @@ module Lydown::CLI::Proofing
     end
     
     def process(opts)
-      if opts[:line_range] == (nil..nil)
-        puts "No change detected"
-      else
+      if opts[:line_range] != (nil..nil)
+        t = Time.now.strftime("%H:%M:%S")
+        puts "[#{t}] Changed: #{opts[:base_path]} (lines #{opts[:line_range].inspect})"
         Lydown::CLI::Compiler.process(opts)
       end
     end

data/lib/lydown/core_ext.rb

@@ -1,3 +1,5 @@
+require 'escape_utils'
+
 class Hash
   # Merges self with another hash, recursively.
   #
@@ -137,6 +139,33 @@ class String
       end
     }
   end
+  
+  def calculate_line_indexes
+    i = -1
+    indexes = {0 => 0}
+    line = 1
+    while i = index("\n", i + 1)
+      indexes[line] = i + 1 # first character after line break
+      line += 1
+    end
+    indexes
+  end
+  
+  def find_line_and_column(index)
+    @line_indexes ||= calculate_line_indexes
+    line = @line_indexes.reverse_each {|l, i| break l if i <= index}
+    
+    # return line and column
+    if line.nil?
+      [nil, nil]
+    else
+      [(line + 1), (index - @line_indexes[line] + 1)]
+    end
+  end
+  
+  def uri_escape
+    EscapeUtils.escape_uri(self)
+  end
 end
 
 class Fixnum

data/lib/lydown/lilypond.rb

@@ -49,9 +49,9 @@ module Lydown
         # Run lilypond, pipe source into its STDIN, and capture its STDERR
         cmd = 'lilypond -lERROR '
         cmd << "-o #{opts[:output_filename]} "
+        cmd << "-dno-point-and-click "
         cmd << "--#{opts[:format]} " if opts[:format]
         cmd << '-s - 2>&1'
-        # cmd << "-s #{ly_path} 2>&1"
         
         err_info = ''
         IO.popen(cmd, 'r+') do |f|

data/lib/lydown/parsing.rb

@@ -15,7 +15,10 @@ class LydownParser
       STDERR.puts error_msg
       raise LydownError, error_msg
     else
-      ast.to_stream
+      stream = []
+      # insert source ref event into stream if we have a filename ref
+      stream << {type: :source_ref}.merge(opts) if opts[:filename]
+      ast.to_stream(stream, opts)
     end
   end
 

data/lib/lydown/parsing/lydown.treetop

@@ -11,7 +11,8 @@ grammar Lydown
     '=music' white_space? [\n] music ([\n] !stream_breaker music)*
   end
   rule lyrics_stream
-    '=lyrics' stream_idx? white_space? [\n] lyrics_content ([\n] !stream_breaker lyrics_content)* <Lyrics>
+    '=lyrics' stream_idx? white_space? [\n] lyrics_content 
+      ([\n] !stream_breaker lyrics_content)* <Lyrics>
   end
   rule stream_breaker
     stream_switch / stream_breaking_setting
@@ -29,7 +30,8 @@ grammar Lydown
     [^\n]* <CommentContent>
   end
   rule setting
-    white_space? '-' white_space* setting_key ':' setting_value comment? <Setting>
+    white_space? '-' white_space* setting_key ':' setting_value 
+      comment? <Setting>
   end
   rule setting_key
     [a-z0-9_]+ <Setting::Key>
@@ -44,13 +46,12 @@ grammar Lydown
     [ \t]+
   end
   rule event
-    (inline_command / inline_lyrics / voice_selector / barline / grace_duration / duration / 
-      chord / note / standalone_figures / rest / silence / phrasing / tie) white_space*
+    (inline_command / inline_lyrics / voice_selector / barline / source_ref / 
+      grace_duration / duration / chord / note / standalone_figures / rest / 
+      silence / phrasing / tie) white_space*
   end
   rule barline
     ('?|' / ':|][|:' / '[|:' / ':|]' / [\|\.\:]+) <Barline>
-    # ('|' / '.' / '||' / '.|' / '..' / '|.|' / '|.' /
-    #  '.|') <Barline>
   end
   rule duration
     tuplet_value / duration_value / duration_macro
@@ -83,7 +84,8 @@ grammar Lydown
     (macro_name / macro_event*) <DurationMacroExpression>
   end
   rule macro_event
-    (duration / note_placeholder / rest / silence / phrasing / tie) white_space*
+    (duration / note_placeholder / rest / silence / 
+      phrasing / tie) white_space*
   end
   rule macro_name
     [a-zA-Z_] [a-zA-Z0-9_]*
@@ -191,4 +193,13 @@ grammar Lydown
   rule voice_selector
     [1234u] ':' <VoiceSelector>
   end
+  rule source_ref
+  '{' source_line ':' source_column '}' <SourceRef>
+  end
+  rule source_line
+    [\d]+ <SourceRef::Line>
+  end
+  rule source_column
+    [\d]+ <SourceRef::Column>
+  end  
 end

data/lib/lydown/parsing/nodes.rb

@@ -1,22 +1,44 @@
 module Lydown::Parsing
   module Root
-    def _to_stream(element, stream)
+    def _to_stream(element, stream, opts)
       if element.elements
         element.elements.each do |e|
-          e.respond_to?(:to_stream) ? e.to_stream(stream) : _to_stream(e, stream)
+          e.respond_to?(:to_stream) ? 
+            e.to_stream(stream, opts) : 
+            _to_stream(e, stream, opts)
         end
       end
       stream
     end
-
-    def to_stream(stream = [])
-      _to_stream(self, stream)
+    
+    def to_stream(stream = [], opts = {})
+      _to_stream(self, stream, opts)
       stream
     end
+    
+    def event_hash(stream, opts, hash = {})
+      if source = opts[:source]
+        last = stream.last
+        if last && last[:type] == :source_ref && last[:line]
+          line, column = last[:line], last[:column]
+        else
+          line, column = source.find_line_and_column(interval.first)
+        end
+
+        hash.merge({
+          filename: opts[:filename],
+          source: source,
+          line: line,
+          column: column
+        })
+      else
+        hash
+      end
+    end
   end
 
   module CommentContent
-    def to_stream(stream)
+    def to_stream(stream, opts)
       stream << {type: :comment, content: text_value.strip}
     end
   end
@@ -24,28 +46,30 @@ module Lydown::Parsing
   module Setting
     include Root
 
-    def to_stream(stream)
+    def to_stream(stream, opts)
       level = (text_value =~ /^([\s]+)/) ? ($1.length / 2) : 0
-      @setting = {type: :setting, level: level}
-      _to_stream(self, stream)
+      @setting = event_hash(stream, opts, {
+        type: :setting, level: level
+      })
+      _to_stream(self, stream, opts)
     end
-
+    
     def setting
       @setting
     end
-
+    
     def emit_setting(stream)
       stream << @setting
     end
 
     module Key
-      def to_stream(stream)
+      def to_stream(stream, opts)
         parent.setting[:key] = text_value
       end
     end
 
     module Value
-      def to_stream(stream)
+      def to_stream(stream, opts)
         parent.setting[:value] = text_value.strip
         parent.emit_setting(stream)
       end
@@ -53,13 +77,19 @@ module Lydown::Parsing
   end
 
   module DurationValue
-    def to_stream(stream)
-      stream << {type: :duration, value: text_value}
+    include Root
+    
+    def to_stream(stream, opts)
+      stream << event_hash(stream, opts, {
+        type: :duration, value: text_value
+      })
     end
   end
 
   module TupletValue
-    def to_stream(stream)
+    include Root
+    
+    def to_stream(stream, opts)
       if text_value =~ /^(\d+)%((\d+)\/(\d+))?$/
         value, fraction, group_length = $1, $2, $4
         unless fraction
@@ -67,26 +97,30 @@ module Lydown::Parsing
           group_length = '2'
         end
 
-        stream << {
+        stream << event_hash(stream, opts, {
           type: :tuplet_duration,
           value: value,
           fraction: fraction,
           group_length: group_length
-        }
+        })
       end
     end
   end
 
   module GraceDuration
+    include Root
+    
     GRACE_KIND = {
       nil => :grace,
       '/' => :acciaccatura,
       '^' => :appoggiatura
     }
     
-    def to_stream(stream)
+    def to_stream(stream, opts)
       if text_value =~ /^\$([\/\^])?(\d+)$/
-        stream << {type: :grace, value: $2, kind: GRACE_KIND[$1]}
+        stream << event_hash(stream, opts, {
+          type: :grace, value: $2, kind: GRACE_KIND[$1]
+        })
       end
     end
   end
@@ -94,14 +128,16 @@ module Lydown::Parsing
   module Note
     include Root
 
-    def to_stream(stream)
-      note = {type: :note, raw: text_value}
-      _to_stream(self, note)
+    def to_stream(stream, opts)
+      note = event_hash(stream, opts, {
+        type: :note, raw: text_value
+      })
+      _to_stream(self, note, opts)
       stream << note
     end
 
     module Head
-      def to_stream(note)
+      def to_stream(note, opts)
         # remove octave marks from note head (this is only in case the order
         # accidental-octave was reversed)
         head = text_value.gsub(/[',]+/) {|m| note[:octave] = m; ''}
@@ -110,19 +146,19 @@ module Lydown::Parsing
     end
 
     module Octave
-      def to_stream(note)
+      def to_stream(note, opts)
         note[:octave] = text_value
       end
     end
 
     module AccidentalFlag
-      def to_stream(note)
+      def to_stream(note, opts)
         note[:accidental_flag] = text_value
       end
     end
 
     module Expression
-      def to_stream(note)
+      def to_stream(note, opts)
         note[:expressions] ||= []
         note[:expressions] << text_value
       end
@@ -132,15 +168,17 @@ module Lydown::Parsing
   module Chord
     include Root
     
-    def to_stream(stream)
-      chord = {type: :chord, notes: []}
-      _to_stream(self, chord[:notes])
+    def to_stream(stream, opts)
+      chord = event_hash(stream, opts, {
+        type: :chord, notes: []
+      })
+      _to_stream(self, chord[:notes], opts)
       stream << chord
     end
   end
 
   module FiguresComponent
-    def to_stream(note)
+    def to_stream(note, opts)
       note[:figures] ||= []
       note[:figures] << text_value
     end
@@ -149,47 +187,47 @@ module Lydown::Parsing
   module StandAloneFigures
     include Root
 
-    def to_stream(stream)
+    def to_stream(stream, opts)
       note = {type: :stand_alone_figures}
-      _to_stream(self, note)
+      _to_stream(self, note, opts)
       stream << note
     end
   end
 
   module Phrasing
     module BeamOpen
-      def to_stream(stream)
+      def to_stream(stream, opts)
         stream << {type: :beam_open}
       end
     end
 
     module BeamClose
-      def to_stream(stream)
+      def to_stream(stream, opts)
         stream << {type: :beam_close}
       end
     end
 
     module SlurOpen
-      def to_stream(stream)
+      def to_stream(stream, opts)
         stream << {type: :slur_open}
       end
     end
 
     module SlurClose
-      def to_stream(stream)
+      def to_stream(stream, opts)
         stream << {type: :slur_close}
       end
     end
   end
 
   module Tie
-    def to_stream(stream)
+    def to_stream(stream, opts)
       stream << {type: :tie}
     end
   end
 
   module ShortTie
-    def to_stream(stream)
+    def to_stream(stream, opts)
       stream << {type: :short_tie}
     end
   end
@@ -197,40 +235,50 @@ module Lydown::Parsing
   module Rest
     include Root
     
-    def to_stream(stream)
-      rest = {type: :rest, raw: text_value, head: text_value[0]}
+    def to_stream(stream, opts)
+      rest = event_hash(stream, opts, {
+        type: :rest, raw: text_value, head: text_value[0]
+      })
       if text_value =~ /^R(\*([0-9]+))?$/
         rest[:multiplier] = $2 || '1'
       end
 
-      _to_stream(self, rest)
+      _to_stream(self, rest, opts)
 
       stream << rest
     end
   end
 
   module Silence
-    def to_stream(stream)
-      stream << {type: :silence, raw: text_value, head: text_value[0]}
+    include Root
+    
+    def to_stream(stream, opts)
+      stream << event_hash(stream, opts, {
+        type: :silence, raw: text_value, head: text_value[0]
+      })
     end
   end
 
   module DurationMacroExpression
-    def to_stream(stream)
-      stream << {type: :duration_macro, macro: text_value}
+    include Root
+    
+    def to_stream(stream, opts)
+      stream << event_hash(stream, opts, {
+        type: :duration_macro, macro: text_value
+      })
     end
   end
 
   module Lyrics
     include Root
-    def to_stream(stream)
+    def to_stream(stream, opts)
       o = {type: :lyrics}
-      _to_stream(self, o)
+      _to_stream(self, o, opts)
       stream << o
     end
     
     module Content
-      def to_stream(o)
+      def to_stream(o, opts)
         if o[:content]
           o[:content] << ' ' << text_value
         else
@@ -240,7 +288,7 @@ module Lydown::Parsing
     end
     
     module QuotedContent
-      def to_stream(o)
+      def to_stream(o, opts)
         if text_value =~ /^"(.+)"$/
           content = $1
         else
@@ -257,7 +305,7 @@ module Lydown::Parsing
   end
   
   module StreamIndex
-    def to_stream(o)
+    def to_stream(o, opts)
       idx = (text_value =~ /\(([\d]+)\)/) && $1.to_i
       if idx.nil?
         raise LydownError, "Invalid stream index (#{text_value.inspect})"
@@ -267,24 +315,27 @@ module Lydown::Parsing
   end
 
   module Barline
-    def to_stream(stream)
+    def to_stream(stream, opts)
       stream << {type: :barline, barline: text_value}
     end
   end
   
   module Command
     include Root
-    def to_stream(stream)
-      cmd = {type: :command, raw: text_value}
+    
+    def to_stream(stream, opts)
+      cmd = event_hash(stream, opts, {
+        type: :command, raw: text_value
+      })
       cmd[:once] = true if text_value =~ /^\\\!/
-      _to_stream(self, cmd)
+      _to_stream(self, cmd, opts)
       stream << cmd
     end
     
     SETTING_KEYS = %w{time key clef}
     
     module Key
-      def to_stream(cmd)
+      def to_stream(cmd, opts)
         cmd[:key] = text_value
         if SETTING_KEYS.include?(text_value)
           cmd[:type] = :setting
@@ -293,7 +344,7 @@ module Lydown::Parsing
     end
     
     module Argument
-      def to_stream(cmd)
+      def to_stream(cmd, opts)
         if text_value =~ /^"(.+)"$/
           value = $1.unescape
         else
@@ -311,9 +362,30 @@ module Lydown::Parsing
   end
   
   module VoiceSelector
-    def to_stream(stream)
+    def to_stream(stream, opts)
       voice = (text_value =~ /^([1234])/) && $1.to_i
       stream << {type: :voice_select, voice: voice}
     end
   end
+  
+  module SourceRef
+    include Root
+    def to_stream(stream, opts)
+      ref = {type: :source_ref, raw: text_value}
+      _to_stream(self, ref, opts)
+      stream << ref
+    end
+    
+    module Line
+      def to_stream(ref, opts)
+        ref[:line] = text_value.to_i
+      end
+    end
+    
+    module Column
+      def to_stream(ref, opts)
+        ref[:column] = text_value.to_i
+      end
+    end
+  end
 end

data/lib/lydown/rendering.rb

@@ -10,6 +10,8 @@ require 'lydown/rendering/staff'
 require 'lydown/rendering/movement'
 require 'lydown/rendering/command'
 require 'lydown/rendering/voices'
+require 'lydown/rendering/source_ref'
+require 'lydown/rendering/skipping'
 
 require 'yaml'
 

data/lib/lydown/rendering/command.rb

@@ -4,12 +4,21 @@ module Lydown::Rendering
     
     def translate
       if @work['process/duration_macro']
-        add_macro_event(@event[:raw])
+        add_macro_event(@event[:raw] || cmd_to_lydown(@event))
       else
         once = @event[:once] ? '\once ' : ''
         cmd = "#{once}\\#{@event[:key]} #{(@event[:arguments] || []).join(' ')} "
         @work.emit(:music, cmd)
       end
     end
+    
+    def cmd_to_lydown(event)
+      cmd = "\\#{event[:key]}"
+      if event[:arguments]
+        cmd << ":"
+        cmd << event[:arguments].map {|a| a.inspect}.join(':')
+      end
+      cmd
+    end
   end
 end

data/lib/lydown/rendering/notes.rb

@@ -106,6 +106,11 @@ module Lydown::Rendering
       else
         @work['process/last_value'] = value
       end
+      
+      if event[:line] && @work['options/proof_mode']
+        @work.emit(event[:stream] || :music, note_event_url_link(event))
+        # @work.emit(event[:stream] || :music, "%{#{event[:line]}:#{event[:column]}%}")
+      end
 
       code = lilypond_note(event, options.merge(value: value))
       @work.emit(event[:stream] || :music, code)
@@ -219,7 +224,9 @@ module Lydown::Rendering
       @work['process/macro_group'] ||= @work['process/duration_macro'].clone
       underscore_count = 0
 
-      lydown_note = "%s%s%s%s%s%s%s" % [
+      lydown_note = "{%d:%d}%s%s%s%s%s%s%s" % [
+        event[:line] || 0,
+        event[:column] || 0,
         lydown_phrasing_open(event),
         event[:head], event[:octave], event[:accidental_flag],
         lydown_phrasing_close(event),
@@ -240,7 +247,10 @@ module Lydown::Rendering
 
       # if group is complete, compile it just like regular code
       unless @work['process/macro_group'].include?('_')
-        code = LydownParser.parse(@work['process/macro_group'])
+        code = LydownParser.parse(@work['process/macro_group'], {
+          filename: event[:filename],
+          source:   event[:source]
+        })
 
         # stash macro
         macro = @work['process/duration_macro']
@@ -312,5 +322,20 @@ module Lydown::Rendering
           gsub(/__([^_]+)__/) {|m| "\\bold { #{$1} }" }.
           gsub(/_([^_]+)_/) {|m| "\\italic { #{$1} }" }
     end
+    
+    TEXTMATE_URL = "txmt://open?url=file://%s&line=%d&column=%d"
+    
+    ADD_LINK_COMMAND = '\once \override NoteHead.after-line-breaking =
+            #(add-link "%s") '
+    
+    def note_event_url_link(event)
+      url = TEXTMATE_URL % [
+        File.expand_path(event[:filename]).uri_escape,
+        event[:line],
+        event[:column]
+      ]
+      
+      ADD_LINK_COMMAND % [url]
+    end
   end
 end

data/lib/lydown/rendering/skipping.rb

@@ -0,0 +1,49 @@
+module Lydown::Rendering
+  class << self
+    SKIP_ON_CMD = {type: :command, key: 'set', arguments: ['Score.skipTypesetting = ##t']}
+    SKIP_OFF_CMD = {type: :command, key: 'set', arguments: ['Score.skipTypesetting = ##f']}
+    
+    BARLINE = {type: :barline, barline: '|'}
+    BAR_NUMBERS_CMD = {type: :command, key: 'set', arguments: ['Score.barNumberVisibility = #all-bar-numbers-visible']}
+    
+    HIGHLIGHT_NOTES_CMD = {type: :command, key: 'override', arguments: ['NoteHead.color = #red']}
+    NORMAL_NOTES_CMD = {type: :command, key: 'override', arguments: ['NoteHead.color = #black']}
+
+    def insert_skip_markers(stream, line_range)
+      # find indexes of first and last changed lines
+      changed_first_idx = find_line_idx(stream, line_range.first)
+      changed_last_idx =  find_line_idx(stream, line_range.last, true)
+      
+      # find index of first line to include
+      start_line = line_range.first - 2; start_line = 0 if start_line < 0
+      start_idx = find_line_idx(stream, start_line)
+      
+      if changed_last_idx
+        stream.insert(changed_last_idx + 1, NORMAL_NOTES_CMD)
+      end
+      
+      if changed_first_idx
+        stream.insert(changed_first_idx, BARLINE)
+        stream.insert(changed_first_idx, BAR_NUMBERS_CMD)
+        stream.insert(changed_first_idx, HIGHLIGHT_NOTES_CMD)
+      end
+      
+      if start_line > 0 && start_idx
+        stream.insert(start_idx, SKIP_OFF_CMD)
+        stream.insert(0, SKIP_ON_CMD)
+      end
+    end
+    
+    # returns index of first event at or after specified line
+    def find_line_idx(stream, line, last = false)
+      if last
+        stream.reverse_each do |e| 
+          return stream.index(e) if e[:line] && e[:line] <= line
+        end
+        nil
+      else
+        stream.index {|e| e[:line] && e[:line] >= line}
+      end
+    end
+  end
+end

data/lib/lydown/rendering/source_ref.rb

@@ -0,0 +1,15 @@
+module Lydown::Rendering
+  # SourceRef does nothing, it's only there to provide line, column references
+  # for notes in a macro group
+  class SourceRef < Base
+    def translate
+      return # unless @work['options/proof_mode']
+
+      fn = @event[:filename]
+      if fn && fn != @work['process/last_filename']
+        @work['process/last_filename'] = fn
+        @work.emit(@event[:stream] || :music, "%{::#{File.expand_path(fn)}%} ")
+      end
+    end
+  end
+end

data/lib/lydown/version.rb

@@ -1,3 +1,3 @@
 module Lydown
-  VERSION = "0.7.1"
+  VERSION = "0.7.2"
 end

data/lib/lydown/work.rb

@@ -246,46 +246,20 @@ module Lydown
       end
     end
     
-    SKIP_ON = "\\set:\"Score.skipTypesetting = ##t\""
-    SHOW_BAR_NUMBERS = "\\set:\"Score.barNumberVisibility = #all-bar-numbers-visible\" |"
-    SKIP_OFF = "\\set:\"Score.skipTypesetting = ##f\""
-    
-    HIGHLIGHT = "\\large \\override:\"NoteHead.color = #red\""
-    NORMAL = "\\large \\override:\"NoteHead.color = #black\""
-    
-    def insert_skip_markers(content, range)
-      unless range.first.nil?
-        lines = content.lines
-        start = range.first - 2; start = 0 if start < 0
-        stop = range.last + 2; stop = lines.size if stop > lines.size
-        
-        lines.insert(stop, "| #{SKIP_ON}")
-        lines.insert(range.last + 1, NORMAL)
-        if start > 0
-          lines.insert(range.first, HIGHLIGHT)
-          lines.insert(start, SHOW_BAR_NUMBERS)
-          lines.insert(start, NORMAL)
-          lines.insert(start, SKIP_OFF)
-          lines.insert(0, SKIP_ON)
-        else
-          lines.insert(0, SHOW_BAR_NUMBERS)
-        end
-        
-        lines.join("\n")
-      else
-        content
-      end
-    end
-
     def process_lydown_file(path, prefix = [], opts = {})
       return unless File.file?(path)
 
       content = IO.read(path)
+      stream = LydownParser.parse(content, {
+        filename: File.expand_path(path),
+        source: content
+      })
+      
       if opts[:line_range]
-        content = insert_skip_markers(content, opts[:line_range])
+        Lydown::Rendering.insert_skip_markers(stream, opts[:line_range])
       end
       
-      process(prefix + LydownParser.parse(content))
+      process(prefix + stream)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lydown
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-01 00:00:00.000000000 Z
+date: 2015-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop
@@ -57,6 +57,8 @@ files:
 - lib/lydown/rendering/music.rb
 - lib/lydown/rendering/notes.rb
 - lib/lydown/rendering/settings.rb
+- lib/lydown/rendering/skipping.rb
+- lib/lydown/rendering/source_ref.rb
 - lib/lydown/rendering/staff.rb
 - lib/lydown/rendering/voices.rb
 - lib/lydown/templates.rb