lydown 0.3.0

data/lib/lydown/templates/part.erb

@@ -0,0 +1,55 @@
+<%
+  title = nil
+  if name && (name != '')
+    title = Lydown::Rendering.part_title(name)
+  end
+  id = "#{title && title.gsub(' ', '')}Staff"
+
+  score_mode = self['render_opts/mode'] == :score
+
+  clef = Lydown::Rendering::Staff.clef(name)
+  beaming_mode = Lydown::Rendering::Staff.beaming_mode(name)
+  partial = self[:pickup] ? "\\partial #{self[:pickup]}" : ""
+
+  end_barline = Lydown::Rendering::Staff.end_barline(self, movement)
+
+  cadenza = self[:time] == 'unmetered'
+%>
+
+<<
+
+\new Staff = <%= id %> \with {
+}
+
+\context Staff = <%= id %> {
+<% if score_mode %>\set Staff.instrumentName = #"<%= title %>"<% end %>
+  \relative c {
+    <% if clef %>
+        \clef "<%= clef %>"
+    <% end %>
+    <%= beaming_mode %>
+    <%= partial %>
+    <%= part['music'] %>
+
+    <% if end_barline %>
+      \bar "<%= end_barline %>"
+    <% end %>
+  }
+}
+
+  <% if part['lyrics'] %>
+    \addlyrics {
+      <%= part['lyrics'] %>
+    }
+  <% end %>
+
+  <% if part['lyrics2'] %>
+    \addlyrics {
+      <%= part['lyrics2'] %>
+    }
+  <% end %>
+
+  <% if part['figures'] %>
+    \figures { <%= part['figures'] %> }
+  <% end %>
+>>

data/lib/lydown/templates.rb

@@ -0,0 +1,22 @@
+require 'erb'
+
+module Lydown
+  module Templates
+    TEMPLATES_DIR = File.join(File.dirname(__FILE__), 'templates')
+    
+    @@templates = {}
+    
+    def self.render(name, ctx, locals = {})
+      _binding = ctx.respond_to?(:template_binding) ? ctx.template_binding(locals) : binding
+      template(name).result(_binding)
+    end
+    
+    def self.template(name)
+      @@templates[name] ||= load_template(name)
+    end
+    
+    def self.load_template(name)
+      ERB.new IO.read(File.join(TEMPLATES_DIR, "#{name}.erb")), 0, '<>'
+    end
+  end
+end

data/lib/lydown/version.rb

@@ -0,0 +1,3 @@
+module Lydown
+  VERSION = "0.3.0"
+end

data/lib/lydown/work.rb

@@ -0,0 +1,192 @@
+require 'lydown/core_ext'
+require 'lydown/templates'
+
+require 'pp'
+
+module Lydown
+  # Work is a virtual lilypond document. It can contain multiple movements,
+  # and each movement can contain multiple parts. Each part can contain multiple
+  # streams: music, lyrics, figured bass.
+  #
+  # A Work instance is created in order to translate lydown code into a
+  # virtual lilypond document, and then render it. The actual rendering may
+  # include all of the streams in the document, or only a selection,such as a
+  # specific movement, a specific part, or a specific stream type.
+  class Work
+    attr_accessor :context
+
+    def initialize(opts = {})
+      @context = {}.deep!
+      reset_context(:work)
+
+      opts.each {|k, v| @context[k] = v}
+
+      process_work_files if opts[:path]
+    end
+
+    def reset_context(mode)
+      case mode
+      when :work, :movement
+        @context[:time] = '4/4'
+        @context[:cadenza_mode] = nil
+        @context[:key] = 'c major'
+        @context[:pickup] = nil
+        @context[:beaming] = nil
+        @context[:end_barline] = nil
+        @context[:part] = nil
+        @context['process/duration_values'] = ['4']
+        @context['process/running_values'] = []
+        @context['process/last_value'] = nil
+        @context['process/last_figures_value'] = nil
+      when :part
+        @context['process/duration_values'] = ['4']
+        @context['process/running_values'] = []
+        @context['process/last_value'] = nil
+        @context['process/last_figures_value'] = nil
+      end
+    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)
+      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
+    end
+
+    def emit(stream_type, *content)
+      stream = current_stream(stream_type)
+
+      content.each {|c| stream << c}
+    end
+
+    def current_stream(type)
+      movement = @context[:movement]
+      part = @context[:part]
+      path = "movements/#{movement}/parts/#{part}/#{type}"
+      @context[path] ||= ''
+    end
+
+    def to_lilypond(opts = {})
+      @context['render_opts'] = opts
+      ly_code = ''
+
+      if opts[:stream_path]
+        unless @context[opts[:stream_path]]
+          raise LydownError, "Invalid stream path #{opts[:stream_path].inspect}"
+        end
+        @context[opts[:stream_path]].strip
+      else
+        @original_context = @context
+        begin
+          @context = filter_context(opts)
+          Lydown::Templates.render(:lilypond_doc, self)
+        ensure
+          @context = @original_context
+        end
+      end
+    end
+
+    def filter_context(opts = {})
+      filtered = @context.deep_clone
+
+      # delete default movement if other movements are present
+      if filtered['movements'].size > 1
+        filtered['movements'].delete('')
+      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
+      end
+
+      if opts[:parts]
+        opts[:parts] = [opts[:parts]] unless opts[:parts].is_a?(Array)
+      end
+      filtered['movements'].each do |name, m|
+        # delete default part if other parts are present
+        if m['parts'].size > 1
+          m['parts'].delete('')
+        end
+
+        if opts[:parts]
+          m['parts'].select! do |pname, p|
+            opts[:parts].include?(pname.to_s)
+          end
+        end
+      end
+
+      filtered
+    end
+
+    def compile(opts = {})
+      code = to_lilypond(opts)
+
+      Lydown::Lilypond.compile(code, opts)
+    end
+
+    def [](path)
+      context[path]
+    end
+
+    def []=(path, value)
+      context[path] = value
+    end
+
+    def process_work_files
+      path = @context[: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}"
+      end
+    end
+
+    DEFAULT_BASENAMES = %w{work movement}
+
+    def process_directory(path, recursive = true)
+      # process work code
+      process_lydown_file(File.join(path, 'work.ld'))
+
+      # process movement specific code
+      process_lydown_file(File.join(path, 'movement.ld'))
+
+      # Iterate over sorted directory entries
+      Dir["#{path}/*"].entries.sort.each do |entry|
+        if File.file?(entry) && (entry =~ /\.ld$/)
+          basename = File.basename(entry, '.*')
+          unless DEFAULT_BASENAMES.include?(basename)
+            part_code = [{type: :setting, key: 'part', value: basename}]
+            lydown_code = part_code + LydownParser.parse(IO.read(entry))
+            process(lydown_code)
+          end
+        elsif File.directory?(entry) && recursive
+          basename = File.basename(entry)
+          # set movement
+          process([{type: :setting, key: 'movement', value: basename}])
+          process_directory(entry, false)
+        end
+      end
+    end
+
+    def process_lydown_file(path)
+      process LydownParser.parse(IO.read(path)) if File.file?(path)
+    end
+  end
+end

data/lib/lydown.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+
+module Lydown; end
+
+require 'lydown/core_ext'
+require 'lydown/errors'
+require 'lydown/parsing'
+require 'lydown/templates'
+require 'lydown/rendering'
+require 'lydown/lilypond'
+require 'lydown/work'

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: lydown
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Sharon Rosner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: 'Lydown '
+email: ciconia@gmail.com
+executables:
+- lydown
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/lydown
+- lib/lydown.rb
+- lib/lydown/core_ext.rb
+- lib/lydown/errors.rb
+- lib/lydown/lilypond.rb
+- lib/lydown/parsing.rb
+- lib/lydown/parsing/lydown.treetop
+- lib/lydown/parsing/nodes.rb
+- lib/lydown/rendering.rb
+- lib/lydown/rendering/base.rb
+- lib/lydown/rendering/comments.rb
+- lib/lydown/rendering/defaults.yml
+- lib/lydown/rendering/figures.rb
+- lib/lydown/rendering/lyrics.rb
+- lib/lydown/rendering/movement.rb
+- lib/lydown/rendering/music.rb
+- lib/lydown/rendering/settings.rb
+- lib/lydown/rendering/staff.rb
+- lib/lydown/templates.rb
+- lib/lydown/templates/lilypond_doc.erb
+- lib/lydown/templates/movement.erb
+- lib/lydown/templates/part.erb
+- lib/lydown/version.rb
+- lib/lydown/work.rb
+homepage: http://github.com/ciconia/lydown
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Lydown is a language for music notation
+test_files: []