lydown 0.7.2 → 0.9.0

data/lib/lydown/translation/ripple/ripple.treetop

@@ -0,0 +1,100 @@
+grammar Ripple
+  include Lydown::Translation::Ripple
+
+  rule events
+    white_space? event* <Root>
+  end
+  
+  rule white_space
+    [ \t\n]+
+  end
+  
+  rule event
+    (relative_cmd / curly_brace / key_signature / time_signature /
+    full_rest / note / phrasing / named_macro / stop_macro / command) white_space?
+  end
+  
+  rule relative_cmd
+    '\relative' [\s]+ relative_cmd_note
+  end
+  
+  rule relative_cmd_note
+    [a-g] accidental? octave* <RelativeCommand>
+  end
+  
+  rule curly_brace
+    [\{\}]
+  end
+  
+  rule key_signature
+    '\key' [\s]+ note_head [\s+] key_mode <KeySignature>
+  end
+  
+  rule key_mode
+    '\major' / '\minor' <KeySignature::Mode>
+  end
+  
+  rule note
+    note_head duration? expression* <Note>
+  end
+  
+  rule note_head
+    [a-gr] accidental octave* accidental_flag? <Note::Head>
+  end
+  
+  rule octave
+    [,']+
+  end
+  
+  rule accidental
+    ('b' / 's' / 'es')*
+  end
+  
+  rule accidental_flag
+    [\!\?]+
+  end
+  
+  rule duration
+    [0-9]+ '.'* <Note::Duration>
+  end
+  
+  rule expression
+    '\\' [a-zA-Z]+ <Note::Expression>
+  end
+
+  rule time_signature
+    '\time' [\s]+ time_signature_content
+  end
+  
+  rule time_signature_content
+    [0-9\/]+ <TimeSignature>
+  end
+  
+  rule full_rest
+    'R' [0-9]+ ('*' [0-9]+)? <FullRest>
+  end
+  
+  rule phrasing
+    [\(\)\[\]\~] <Phrasing>
+  end
+  
+  rule named_macro
+    '$' [a-z0-9]+ <NamedMacro>
+  end
+  
+  rule stop_macro
+    '$$' <NamedMacro::Stop>
+  end
+  
+  rule command
+    (clef_command / simple_command) 
+  end
+  
+  rule simple_command
+    '\\' [a-zA-Z]+ <Command>
+  end
+  
+  rule clef_command
+    '\clef ' [a-z0-9_]+ <Command>
+  end
+end

data/lib/lydown/version.rb

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

data/lib/lydown/work.rb

@@ -1,7 +1,6 @@
-require 'lydown/core_ext'
 require 'lydown/templates'
-
-require 'pp'
+require 'lydown/cli/output'
+require 'parallel'
 
 module Lydown
   # Work is a virtual lilypond document. It can contain multiple movements,
@@ -16,81 +15,13 @@ module Lydown
     attr_accessor :context
 
     def initialize(opts = {})
-      @context = {}.deep!
-      reset_context(:work)
-      @context[:options] = opts.deep_clone
+      @context = WorkContext.new(opts)
 
       process_work_files if opts[:path]
     end
-
-    def reset_context(mode)
-      case mode
-      when :work
-        @context[:time] = '4/4'
-        @context[:tempo] = nil
-        @context[:cadenza_mode] = nil
-        @context[:key] = 'c major'
-        @context[:pickup] = nil
-        @context[:beaming] = nil
-        @context[:end_barline] = nil
-        @context[:part] = nil
-      when :movement
-        @context[:part] = nil
-      end
-      if @context['process/tuplet_mode']
-        Lydown::Rendering::TupletDuration.emit_tuplet_end(self)
-      end
-      if @context['process/grace_mode']
-        Lydown::Rendering::Grace.emit_grace_end(self)
-      end
-      
-      if @context['process/voice_selector']
-        Lydown::Rendering::VoiceSelect.render_voices(self)
-      end
-      
-      Lydown::Rendering::Notes.cleanup_duration_macro(self)
-
-      # reset processing variables
-      @context['process'] = {
-        'duration_values' => ['4'],
-        'running_values' => []
-      }
-    end
-
-    # Used to bind to instance when rendering templates
-    def template_binding(locals = {})
-      b = binding
-      locals.each {|k, v| b.local_variable_set(k.to_sym, v)}
-      b
-    end
-
-    # translate a lydown stream into lilypond
-    def process(lydown_stream, opts = {})
-      lydown_stream.each_with_index do |e, idx|
-        if e[:type]
-          Lydown::Rendering.translate(self, e, lydown_stream, idx)
-        else
-          raise LydownError, "Invalid lydown stream event: #{e.inspect}"
-        end
-      end
-      reset_context(:part) unless opts[:no_reset]
-    end
-
-    def emit(path, *content)
-      stream = current_stream(path)
-
-      content.each {|c| stream << c}
-    end
-
-    def current_stream(subpath)
-      if @context['process/voice_selector']
-        path = "process/voices/#{@context['process/voice_selector']}/#{subpath}"
-      else
-        movement = @context[:movement]
-        part = @context[:part]
-        path = "movements/#{movement}/parts/#{part}/#{subpath}"
-      end
-      @context[path] ||= (subpath == :settings) ? {} : ''
+    
+    def translate(stream)
+      @context.translate(stream)
     end
 
     def to_lilypond(opts = {})
@@ -105,161 +36,176 @@ module Lydown
       else
         @original_context = @context
         begin
-          @context = filter_context(opts)
-          Lydown::Templates.render(:lilypond_doc, self)
+          filtered = @context.filter(opts)
+          filtered.extend(TemplateBinding)
+          Lydown::Templates.render(:lilypond_doc, filtered)
         ensure
           @context = @original_context
         end
       end
     end
 
-    def filter_context(opts = {})
-      filtered = @context.deep_clone
+    def process_work_files
+      path = @context[:options][:path]
+      path += '.ld' if File.file?(path + '.ld')
 
-      if filtered['movements'].nil? || filtered['movements'].size == 0
-        # no movements found, so no music
-        raise LydownError, "No music found"
-      elsif filtered['movements'].size > 1
-        # delete default movement if other movements are present
-        filtered['movements'].delete('')
+      if File.file?(path)
+        process_file(path)
+      elsif File.directory?(path)
+        process_directory(path)
+      else
+        raise LydownError, "Could not read #{path}"
       end
+    end
 
-      if opts[:movements]
-        opts[:movements] = [opts[:movements]] unless opts[:movements].is_a?(Array)
-        filtered['movements'].select! do |name, m|
-          opts[:movements].include?(name.to_s)
-        end
+    def process_file(path, prefix = [], opts = {})
+      $stderr.puts path
+      content = IO.read(path)
+      stream = LydownParser.parse(content, {
+        filename: File.expand_path(path),
+        source: content,
+        proof_mode: @context['options/proof_mode']
+      })
+      
+      if opts[:line_range]
+        Lydown::Rendering.insert_skip_markers(stream, opts[:line_range])
       end
+      
+      @context.translate(prefix + stream)
+    end
+
+    DEFAULT_BASENAMES = %w{work movement}
 
-      if opts[:parts]
-        opts[:parts] = [opts[:parts]] unless opts[:parts].is_a?(Array)
+    def process_directory(path)
+      state = {
+        streams:          {},
+        movements:        Hash.new {|h, k| h[k] = {}},
+        current_movement: nil,
+        part_filter:      @context[:options][:parts],
+        mvmt_filter:      @context[:options][:movements]
+      }
+      
+      read_directory(path, true, state)
+      parse_directory_files(state)
+      translate_directory_streams(state)
+    end
+    
+    def read_directory(path, recursive, state)
+      Dir["#{path}/*"].entries.sort.each do |entry|
+        handle_directory_entry(entry, recursive, state)
       end
-      filtered['movements'].each do |name, m|
-        # delete default part if other parts are present
-        if m['parts'].size > 1
-          m['parts'].delete('')
+    end
+    
+    def handle_directory_entry(entry, recursive, state)
+      if File.file?(entry) && (entry =~ /\.ld$/)
+        part = File.basename(entry, '.*')
+        if part == 'work'
+          state[:streams][entry] = nil
+          state[:movements][nil][:work] = entry
+        elsif part == 'movement'
+          state[:streams][entry] = nil
+          state[:movements][state[:current_movement]][:movement] = entry
+        elsif !skip_part?(part, state)
+          state[:streams][entry] = nil
+          state[:movements][state[:current_movement]][part] = entry
         end
-
-        if opts[:parts]
-          m['parts'].select! do |pname, p|
-            opts[:parts].include?(pname.to_s)
-          end
+      elsif File.directory?(entry) && recursive
+        movement = File.basename(entry)
+        unless skip_movement?(movement, state)
+          state[:current_movement] = movement
+          read_directory(entry, false, state)
         end
       end
-
-      filtered
     end
-
-    def compile(opts = {})
-      code = to_lilypond(opts)
-
-      Lydown::Lilypond.compile(code, opts)
+    
+    def skip_part?(part, state)
+      DEFAULT_BASENAMES.include?(part) ||
+        state[:part_filter] && !state[:part_filter].include?(part)
     end
-
-    def [](path)
-      context[path]
+    
+    def skip_movement?(mvmt, state)
+      state[:mvmt_filter] && !state[:mvmt_filter].include?(mvmt)
     end
 
-    def []=(path, value)
-      context[path] = value
-    end
+    PARALLEL_PARSE_OPTIONS = {
+      progress: {
+        title: 'Parse',
+        format: Lydown::CLI::PROGRESS_FORMAT
+      }
+    }
     
-    # Helper method to preserve context while processing a file or directory.
-    # This method is called with a block. After the block is executed, the 
-    # context is restored.
-    def preserve_context
-      old_context = @context
-      new_context = old_context.deep_merge({})
-      @context = new_context
-      yield
-    ensure
-      @context = old_context
-      if new_context['movements']
-        if @context['movements']
-          @context['movements'].deep_merge! new_context['movements']
-        else
-          @context['movements'] = new_context['movements']
-        end
-        if @context['movements/01-intro/parts/violino1/settings'] && @context['movements/01-intro/parts/violino1/settings'].keys.include?('pickup')
-        end
+    PARALLEL_PROCESS_OPTIONS = {
+      progress: {
+        title: 'Process',
+        format: Lydown::CLI::PROGRESS_FORMAT
+      }
+    }
+    
+    def parse_directory_files(state)
+      streams = state[:streams]
+      proof_mode =  @context['options/proof_mode']
+      paths = streams.keys
+
+      processed_streams = Parallel.map(paths, PARALLEL_PARSE_OPTIONS) do |path|
+        content = IO.read(path)
+        LydownParser.parse(content, {
+          filename: File.expand_path(path),
+          source: content,
+          proof_mode: proof_mode,
+          no_progress: true
+        })
       end
+      processed_streams.each_with_index {|s, idx| streams[paths[idx]] = s}
     end
     
-    def set_part_context(part)
-      movement = @context[:movement]
-      path = "movements/#{movement}/parts/#{part}/settings"
-
-      settings = {}.deep!
-      settings[:pickup] = @context[:pickup]
-      settings[:key] = @context[:key]
-      settings[:tempo] = @context[:tempo]
+    def translate_directory_streams(state)
+      # Process work file
+      if path = state[:movements][nil][:work]
+        @context.translate state[:streams][path]
+      end
       
-      @context[path] = settings
+      translate_movement_files(state)
     end
-
-    def process_work_files
-      path = @context[:options][:path]
-      path += '.ld' if File.file?(path + '.ld')
-
-      if File.file?(path)
-        process_lydown_file(path)
-      elsif File.directory?(path)
-        process_directory(path)
-      else
-        raise LydownError, "Could not read #{path}"
+    
+    def translate_movement_files(state)
+      stream_entries = prepare_work_stream_array(state)
+      processed_contexts = Parallel.map(stream_entries, PARALLEL_PROCESS_OPTIONS) do |entry|
+        mvmt_stream, stream = *entry
+        ctx = @context.clone_for_translation
+        ctx.translate(mvmt_stream)
+        ctx.translate(stream)
+        ctx
       end
+      
+      processed_contexts.each {|ctx| @context.merge_movements(ctx)}
     end
+    
+    # An array containing entries for each file/stream to be translated.
+    # Each entry in this array is in the form [mvmt_stream, stream]
+    def prepare_work_stream_array(state)
+      streams = state[:streams]
+      movements = state[:movements]
+      line_range = @context[:options][:line_range]
+      entries = []
+
+      movements.each do |mvmt, mvmt_files|
+        # Construct movement stream, a prefix for the part stream
+        mvmt_stream = [{type: :setting, key: 'movement', value: mvmt}]
+        if path = movements[mvmt][:movement]
+          mvmt_stream += streams[path]
+        end
 
-    DEFAULT_BASENAMES = %w{work movement}
-
-    def process_directory(path, recursive = true)
-      preserve_context do
-        # process work code
-        process_lydown_file(File.join(path, 'work.ld'))
-        # process movement specific code
-        process_lydown_file(File.join(path, 'movement.ld'))
-        
-        part_filter = @context[:options][:parts]
-        mvmt_filter = @context[:options][:movements]
-        
-        # Iterate over sorted directory entries
-        Dir["#{path}/*"].entries.sort.each do |entry|
-          if File.file?(entry) && (entry =~ /\.ld$/)
-            part = File.basename(entry, '.*')
-            skip = part_filter && !part_filter.include?(part)
-            unless DEFAULT_BASENAMES.include?(part) || skip
-              preserve_context do
-                process_lydown_file(entry, [
-                  {type: :setting, key: 'part', value: part}
-                ], line_range: @context[:options][:line_range])
-              end
-            end
-          elsif File.directory?(entry) && recursive
-            movement = File.basename(entry)
-            skip = mvmt_filter && !mvmt_filter.include?(movement)
-            unless skip
-              process([{type: :setting, key: 'movement', value: movement}])
-              process_directory(entry, false)
-            end
+        mvmt_files.each do |part, path|
+          unless part.is_a?(Symbol)
+            stream = streams[path]
+            Lydown::Rendering.insert_skip_markers(stream, line_range) if line_range
+            stream.unshift({type: :setting, key: 'part', value: part})
+            entries << [mvmt_stream, stream]
           end
         end
       end
+      entries
     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]
-        Lydown::Rendering.insert_skip_markers(stream, opts[:line_range])
-      end
-      
-      process(prefix + stream)
-    end
   end
 end