lyp 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: da31da8efa75b8704dab5d48b0c44173cae0d9ff
-  data.tar.gz: da5431609dfffd0e2a0f813231ced74b17a47878
+  metadata.gz: 44457899f8d309c43525243e8b0fcfaf0c856abf
+  data.tar.gz: 263b5f9891b99ee932bce722ef4a67a372ca77fb
 SHA512:
-  metadata.gz: b6dc9a5578f26af2c369a76cb8c9e1798cfd563c8a9bdb620f55dc25b8d75f39aa8a4a93f377ebacc4c9ebfff7b8912765c2a8831c5f9e11cb80eb94a3ea6b54
-  data.tar.gz: ba944bce979da2914064406b47ef8dcccd09e52069d32c12c637ba0c37e3415373b93695f3ef29b56fdca72624bbac0437456808314309856a8e746414d328f8
+  metadata.gz: 64e91346e7be7c10112d9e0552744a542fec4e2c69b8425a9eb4cb65977e65d3615b49417862bf26256d458f40baf6ad5a043df012b51c82ab3e2350cbce2486
+  data.tar.gz: d4e32d5e5f08762646da59bc519e5a1d716170013d428989a75fa12e0da2c9da8dae4198eca73d3a06d651559f4e253e5b47eedfce8bed3c6a3150eb7a6f05a5

data/bin/lilypond

@@ -12,19 +12,11 @@ unless lilypond_path && File.file?(lilypond_path)
   exit 1
 end
 
-if (ARGV == ['-v']) || (ARGV == ['--warranty'])
-  # Show lilypond version and exit
+case ARGV
+when [], ['-v'], ['--warranty'], ['scheme-sandbox']
   exec("#{lilypond_path} #{ARGV.join(' ')}")
-end
-
-if ARGV.size == 0
-  exec(lilypond_path)
 else
-  
   begin
     Lyp::Lilypond.compile(ARGV)
-  # rescue => e
-  #   STDERR.puts e.message
-  #   exit 1
   end
 end

data/lib/lyp/base.rb

@@ -6,7 +6,7 @@ module Lyp
   # before the version number.
   # 
   # Accepted operators: >=, ~>
-  PACKAGE_RE = /^([^@\>~]+)(?:@?((?:\>=|~\>)?.+))?/ #/^([^@]+)(?:@(.+))?$/
+  PACKAGE_RE = /^([^@\>~]+)(?:@?((?:\>=|~\>)?.+))?/
   LILYPOND_RE = /^lilypond(?:@?((?:\>=|~\>)?.+))?/
 
   LYP_DIRECTORY = File.expand_path('~/.lyp')
@@ -15,6 +15,13 @@ module Lyp
   DEFAULT_PACKAGE_DIRECTORY = File.join(LYP_DIRECTORY, 'packages')
   DEFAULT_LILYPONDS_DIRECTORY = File.join(LYP_DIRECTORY, 'lilyponds')
   
+  # Fonts are installed on lilypond >= 2.18.2
+  FONT_COPY_REQ = Gem::Requirement.new('>=2.18.2')
+  FONT_PATCH_REQ = Gem::Requirement.new('>=2.18.2', '<2.19.12')
+  
+  # Font patch filename (required for 2.18.2 <= lilypond < 2.19.12)
+  FONT_PATCH_FILENAME = File.expand_path('etc/font.scm', File.dirname(__FILE__))
+  
   SETTINGS_FILENAME = 'settings.yml'
 
   def self.packages_dir

data/lib/lyp/cli.rb

@@ -95,11 +95,27 @@ class Lyp::CLI < Thor
   end
 
   desc "compile [<option>...] <FILE>", "Invokes lilypond with given file"
+  method_option :install, aliases: '-i', type: :boolean, desc: 'Install the requested version of lilypond if not present'
+  method_option :env, aliases: '-e', type: :boolean, desc: 'Use version set by LILYPOND_VERSION environment variable'
   def compile(*args)
     Lyp::System.test_installed_status!
-    Lyp::Lilypond.check_lilypond!
 
-    Lyp::Lilypond.compile(*args)
+    if options[:env]
+      Lyp::Lilypond.force_env_version!
+      if options[:install] && !Lyp::Lilypond.forced_lilypond
+        Lyp::Lilypond.install(Lyp::Lilypond.forced_version)
+      end
+    else
+      # check lilypond default / current settings
+      Lyp::Lilypond.check_lilypond!
+    end
+    
+    begin
+      Lyp::Lilypond.compile(args)
+    rescue => e
+      puts e.message
+      puts e.backtrace.join("\n")
+    end
   end
 
   desc "install <PACKAGE|lilypond|self>...", "Install a package or a version of lilypond. When 'install self' is invoked, lyp installs itself in ~/.lyp."

data/lib/lyp/etc/font.scm

@@ -0,0 +1,296 @@
+;;;; This file is part of LilyPond, the GNU music typesetter.
+;;;;
+;;;; Copyright (C) 2004--2014 Han-Wen Nienhuys <hanwen@xs4all.nl>
+;;;;
+;;;; LilyPond is free software: you can redistribute it and/or modify
+;;;; it under the terms of the GNU General Public License as published by
+;;;; the Free Software Foundation, either version 3 of the License, or
+;;;; (at your option) any later version.
+;;;;
+;;;; LilyPond is distributed in the hope that it will be useful,
+;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;;; GNU General Public License for more details.
+;;;;
+;;;; You should have received a copy of the GNU General Public License
+;;;; along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+;; This file supplied by Abraham Leigh and used by lyp to patch lilypond 
+;; versions from 2.18.2 to 2.19.11 in order to support custom music fonts.
+
+;; TODO:
+;;
+;; lookup-font should be written in  C.
+;;
+
+;; We have a tree, where each level of the tree is a qualifier
+;; (eg. encoding, family, shape, series etc.)  this defines the levels
+;; in the tree.  The first one is encoding, so we can directly select
+;; between text or music in the first step of the selection.
+(define default-qualifier-order
+  '(font-encoding font-family font-shape font-series))
+
+(define-class <Font-tree-element>
+  ())
+
+(define-class <Font-tree-leaf> (<Font-tree-element>)
+  (default-size #:init-keyword #:default-size)
+  (size-vector  #:init-keyword #:size-vector))
+
+(define-class <Font-tree-node> (<Font-tree-element>)
+  (qualifier #:init-keyword #:qualifier  #:accessor font-qualifier)
+  (default #:init-keyword #:default #:accessor font-default)
+  (children #:init-keyword #:children #:accessor font-children))
+
+(define (make-font-tree-leaf size size-font-vector)
+  (make <Font-tree-leaf> #:default-size size #:size-vector size-font-vector))
+
+(define (make-font-tree-node
+         qualifier default)
+  (make <Font-tree-node>
+    #:qualifier qualifier
+    #:default default
+    #:children (make-hash-table 11)))
+
+(define-method (display (leaf <Font-tree-leaf>) port)
+  (for-each (lambda (x) (display x port))
+            (list
+             "#<Font-size-family:\n"
+             (slot-ref leaf 'default-size)
+             (slot-ref leaf 'size-vector)
+             "#>"
+             )))
+
+(define-method (display (node <Font-tree-node>) port)
+  (for-each
+   (lambda (x)
+     (display x port))
+   (list
+    "Font_node {\nqual: "
+    (font-qualifier node)
+    "(def: "
+    (font-default node)
+    ") {\n"))
+  (for-each
+   (lambda (x)
+     (display "\n")
+     (display (car x) port)
+     (display "=" port)
+     (display (cdr x) port))
+   (hash-table->alist (font-children node)))
+  (display "} }\n"))
+
+
+(define-method (add-font (node <Font-tree-node>) fprops size-family)
+  (define (assoc-delete key alist)
+    (assoc-remove! (list-copy alist) key))
+
+  (define (make-node fprops size-family)
+    (if (null? fprops)
+        (make-font-tree-leaf (car size-family) (cdr size-family))
+        (let* ((qual (next-qualifier default-qualifier-order fprops)))
+          (make-font-tree-node qual
+                               (assoc-get qual fprops)))))
+
+  (define (next-qualifier order props)
+    (cond
+     ((and (null? props) (null? order))
+      #f)
+     ((null? props) (car order))
+     ((null? order) (caar props))
+     (else
+      (if (assoc-get (car order) props)
+          (car order)
+          (next-qualifier (cdr order) props)))))
+
+  (let* ((q (font-qualifier node))
+         (d (font-default node))
+         (v (assoc-get q fprops d))
+         (new-fprops (assoc-delete q fprops))
+         (child (hashq-ref (slot-ref node 'children)
+                           v #f)))
+    (if (not child)
+        (begin
+          (set! child (make-node new-fprops size-family))
+          (hashq-set! (slot-ref node 'children) v child)))
+    (if (pair? new-fprops)
+        (add-font child new-fprops size-family))))
+
+(define-method (add-font (node <Font-tree-leaf>) fprops size-family)
+  (throw "must add to node, not leaf"))
+
+(define-method (g-lookup-font (node <Font-tree-node>) alist-chain)
+  (let* ((qual (font-qualifier node))
+         (def (font-default node))
+         (val (chain-assoc-get qual alist-chain def))
+         (desired-child (hashq-ref (font-children node) val)))
+
+    (if desired-child
+        (g-lookup-font desired-child alist-chain)
+        (g-lookup-font (hashq-ref (font-children node) def) alist-chain))))
+
+(define-method (g-lookup-font (node <Font-tree-leaf>) alist-chain)
+  node)
+
+;; two step call is handy for debugging.
+(define (lookup-font node alist-chain)
+  (g-lookup-font node alist-chain))
+
+;; TODO - we could actually construct this by loading all OTFs and
+;; inspecting their design size fields.
+(define-public feta-design-size-mapping
+  '((11 . 11.22)
+    (13 . 12.60)
+    (14 . 14.14)
+    (16 . 15.87)
+    (18 . 17.82)
+    (20 . 20)
+    (23 . 22.45)
+    (26 . 25.20)))
+
+;; Each size family is a vector of fonts, loaded with a delay.  The
+;; vector should be sorted according to ascending design size.
+(define-public (add-music-fonts node family name brace design-size-alist factor)
+  "Set up music fonts.
+
+Arguments:
+@itemize
+@item
+@var{node} is the font tree to modify.
+
+@item
+@var{family} is the family name of the music font.
+
+@item
+@var{name} is the basename for the music font.
+@file{@var{name}-<designsize>.otf} should be the music font,
+
+@item
+@var{brace} is the basename for the brace font.
+@file{@var{brace}-brace.otf} should have piano braces.
+
+@item
+@var{design-size-alist} is a list of @code{(rounded . designsize)}.
+@code{rounded} is a suffix for font filenames, while @code{designsize}
+should be the actual design size.  The latter is used for text fonts
+loaded through pango/@/fontconfig.
+
+@item
+@var{factor} is a size factor relative to the default size that is being
+used.  This is used to select the proper design size for the text fonts.
+@end itemize"
+  (for-each
+   (lambda (x)
+     (add-font node
+               (list (cons 'font-encoding (car x))
+                     (cons 'font-family family))
+               (cons (* factor (cadr x))
+                     (caddr x))))
+
+   `((fetaText ,(ly:pt 20.0)
+               ,(list->vector
+                 (map (lambda (tup)
+                        (cons (ly:pt (cdr tup))
+                              (format #f "~a-~a ~a"
+                                      name
+                                      (car tup)
+                                      (ly:pt (cdr tup)))))
+                      design-size-alist)))
+     (fetaMusic ,(ly:pt 20.0)
+                ,(list->vector
+                  (map (lambda (size-tup)
+                         (delay (ly:system-font-load
+                                 (format #f "~a-~a" name (car size-tup)))))
+                       design-size-alist
+                       )))
+     (fetaBraces ,(ly:pt 20.0)
+                 #(,(delay (ly:system-font-load
+                            (format #f "~a-brace" brace)))))
+     )))
+
+(define-public (add-pango-fonts node lily-family family factor)
+  ;; Synchronized with the `text-font-size' variable in
+  ;; layout-set-absolute-staff-size-in-module (see paper.scm).
+  (define text-font-size (ly:pt (* factor 11.0)))
+
+  (define (add-node shape series)
+    (add-font node
+              `((font-family . ,lily-family)
+                (font-shape . ,shape)
+                (font-series . ,series)
+                (font-encoding . latin1) ;; ugh.
+                )
+              `(,text-font-size
+                . #(,(cons
+                      (ly:pt 12)
+                      (ly:make-pango-description-string
+                       `(((font-family . ,family)
+                          (font-series . ,series)
+                          (font-shape . ,shape)))
+                       (ly:pt 12)))))))
+
+  (add-node 'upright 'normal)
+  (add-node 'caps 'normal)
+  (add-node 'upright 'bold)
+  (add-node 'italic 'normal)
+  (add-node 'italic 'bold))
+
+; This function allows the user to change the specific fonts, leaving others
+; to the default values. This way, "make-pango-font-tree"'s syntax doesn't
+; have to change from the user's perspective.
+;
+; Usage:
+;   \paper {
+;     #(define fonts
+;       (set-global-fonts
+;        #:music "gonville"  ; (the main notation font)
+;        #:roman "FreeSerif" ; (the main/serif text font)
+;       ))
+;   }
+;
+; Leaving out "#:brace", "#:sans", and "#:typewriter" leave them at 
+; "emmentaler", "sans-serif", and "monospace", respectively. All fonts are
+; still accesible through the usual scheme symbols: 'feta, 'roman, 'sans, and
+; 'typewriter.
+(define*-public (set-global-fonts #:key 
+  (music "emmentaler")
+  (brace "emmentaler")
+  (roman "Century Schoolbook L")
+  (sans "sans-serif")
+  (typewriter "monospace")
+  (factor 1))
+  (let ((n (make-font-tree-node 'font-encoding 'fetaMusic)))
+    (add-music-fonts n 'feta music brace feta-design-size-mapping factor)
+    (add-pango-fonts n 'roman roman factor)
+    (add-pango-fonts n 'sans sans factor)
+    (add-pango-fonts n 'typewriter typewriter factor)
+    n))
+    
+(define-public (make-pango-font-tree roman-str sans-str typewrite-str factor)
+  (let ((n (make-font-tree-node 'font-encoding 'fetaMusic)))
+    (add-music-fonts n 'feta "emmentaler" "emmentaler" feta-design-size-mapping factor)
+    (add-pango-fonts n 'roman roman-str factor)
+    (add-pango-fonts n 'sans sans-str factor)
+    (add-pango-fonts n 'typewriter typewrite-str factor)
+    n))
+
+(define-public (make-century-schoolbook-tree factor)
+  (make-pango-font-tree
+   "Century Schoolbook L"
+   "sans-serif"
+   "monospace"
+   factor))
+
+(define-public all-text-font-encodings
+  '(latin1))
+
+(define-public all-music-font-encodings
+  '(fetaBraces
+    fetaMusic
+    fetaText))
+
+(define-public (magstep s)
+  (exp (* (/ s 6) (log 2))))
+
+(define-public (magnification->font-size m)
+  (* 6 (/ (log m) (log 2))))

data/lib/lyp/lilypond.rb

@@ -32,6 +32,8 @@ module Lyp::Lilypond
     # The current lilypond path is stored in a temporary file named by the 
     # session id. Thus we can persist the version selected by the user
     def current_lilypond
+      return forced_lilypond if @forced_version
+      
       settings = get_session_settings
 
       if !settings[:current]
@@ -48,6 +50,23 @@ module Lyp::Lilypond
       set_session_settings(settings)
     end
     
+    def forced_lilypond
+      lilypond = lyp_lilyponds.find do |l|
+        l[:version] == @forced_version
+      end
+      
+      lilypond && lilypond[:path]
+    end
+    
+    def force_env_version!
+      @forced_version = ENV['LILYPOND_VERSION']
+      unless @forced_version
+        raise "LILYPOND_VERSION not set"
+      end
+    end
+    
+    attr_reader :forced_version
+    
     def check_lilypond!
       # check default
       select_default_lilypond! unless valid_lilypond?(default_lilypond)
@@ -116,9 +135,11 @@ module Lyp::Lilypond
       Dir["#{Lyp.lilyponds_dir}/*"].each do |path|
         next unless File.directory?(path) && File.basename(path) =~ /^[\d\.]+$/
         
+        root_path = path
         version = File.basename(path)
         path = File.join(path, "bin/lilypond")
         list << {
+          root_path: root_path,
           path: path,
           version: version
         }
@@ -136,6 +157,7 @@ module Lyp::Lilypond
           resp = `#{path} -v`
           if resp.lines.first =~ /LilyPond ([0-9\.]+)/i
             m << {
+              root_path: File.expand_path(File.join(File.dirname(path), '..')),
               path: path,
               version: $1,
               system: true
@@ -265,6 +287,9 @@ module Lyp::Lilypond
 
       download_lilypond(url, fn, opts) unless File.file?(fn)
       install_lilypond_files(fn, platform, version, opts)
+      
+      patch_font_scm(version)
+      copy_fonts_from_all_packages(version, opts)
     end
 
     def lilypond_install_url(platform, version, opts)
@@ -368,6 +393,37 @@ module Lyp::Lilypond
       puts e.message
     end
     
+    def patch_font_scm(version)
+      return unless Lyp::FONT_PATCH_REQ =~ Gem::Version.new(version)
+      
+      target_fn = File.join(Lyp.lilyponds_dir, version, 'share/lilypond/current/scm/font.scm')
+      FileUtils.cp(Lyp::FONT_PATCH_FILENAME, target_fn)
+    end
+
+    def copy_fonts_from_all_packages(version, opts)
+      return unless Lyp::FONT_COPY_REQ =~ Gem::Version.new(version)
+      
+      ly_fonts_dir = File.join(Lyp.lilyponds_dir, version, 'share/lilypond/current/fonts')
+      
+      Dir["#{Lyp.packages_dir}/**/fonts"].each do |package_fonts_dir|
+
+        Dir["#{package_fonts_dir}/*.otf"].each do |fn|
+          target_fn = File.join(ly_fonts_dir, 'otf', File.basename(fn))
+          FileUtils.cp(fn, target_fn)
+        end
+        
+        Dir["#{package_fonts_dir}/*.svg"].each do |fn|
+          target_fn = File.join(ly_fonts_dir, 'svg', File.basename(fn))
+          FileUtils.cp(fn, target_fn)
+        end
+        
+        Dir["#{package_fonts_dir}/*.woff"].each do |fn|
+          target_fn = File.join(ly_fonts_dir, 'svg', File.basename(fn))
+          FileUtils.cp(fn, target_fn)
+        end
+      end
+    end
+    
     def use(version, opts)
       lilypond_list = list.reverse
       

data/lib/lyp/package.rb

@@ -67,6 +67,11 @@ module Lyp::Package
       
       install_package_dependencies(info[:path], opts)
       
+      if File.directory?(File.join(info[:path], 'fonts'))
+        puts "Installing package fonts..." unless opts[:silent]
+        install_package_fonts(info[:path], opts)
+      end
+      
       puts "\nInstalled #{package}@#{info[:version]}\n\n" unless opts[:silent]
       
       # important: return the installed version
@@ -105,6 +110,12 @@ module Lyp::Package
         f << LOCAL_PACKAGE_WRAPPER % [entry_point_dirname, entry_point_path]
       end
       
+      # create fonts directory symlink if needed
+      fonts_path = File.join(local_path, 'fonts')
+      if File.directory?(fonts_path)
+        FileUtils.ln_sf(fonts_path, File.join(package_path, 'fonts'))
+      end
+      
       {version: version, path: package_path}
     end
     
@@ -202,6 +213,32 @@ module Lyp::Package
       sub_deps.each {|d| install(d, opts)}
     end
     
+    def install_package_fonts(package_path, opts = {})
+      req = Lyp::FONT_COPY_REQ
+      
+      Lyp::Lilypond.list.each do |lilypond|
+        next unless req =~ Gem::Version.new(lilypond[:version])
+        
+        ly_fonts_dir = File.join(lilypond[:root_path], 'share/lilypond/current/fonts')
+        package_fonts_dir = File.join(package_path, 'fonts')
+        
+        Dir["#{package_fonts_dir}/*.otf"].each do |fn|
+          target_fn = File.join(ly_fonts_dir, 'otf', File.basename(fn))
+          FileUtils.cp(fn, target_fn)
+        end
+        
+        Dir["#{package_fonts_dir}/*.svg"].each do |fn|
+          target_fn = File.join(ly_fonts_dir, 'svg', File.basename(fn))
+          FileUtils.cp(fn, target_fn)
+        end
+        
+        Dir["#{package_fonts_dir}/*.woff"].each do |fn|
+          target_fn = File.join(ly_fonts_dir, 'svg', File.basename(fn))
+          FileUtils.cp(fn, target_fn)
+        end
+      end
+    end
+    
     def package_git_url(package, search_index = true)
       case package
       when /^(?:(?:[^\:]+)|http|https)\:/

data/lib/lyp/system.rb

@@ -124,7 +124,9 @@ EOF
       
       puts "Removing binary scripts..."
       # Delete bin scripts
-      FileUtils.rm("#{Lyp::LYP_BIN_DIRECTORY}/*") rescue nil
+      Dir["#{Lyp::LYP_BIN_DIRECTORY}/*"].each do |fn|
+        FileUtils.rm_f(fn) rescue nil
+      end
       
       puts "\nTo completely remove installed packages and lilyponds run 'rm -rf ~/.lyp'.\n\n"
     end

data/lib/lyp/version.rb

@@ -1,3 +1,3 @@
 module Lyp
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lyp
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-24 00:00:00.000000000 Z
+date: 2016-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
@@ -136,6 +136,7 @@ files:
 - lib/lyp.rb
 - lib/lyp/base.rb
 - lib/lyp/cli.rb
+- lib/lyp/etc/font.scm
 - lib/lyp/git_based_rugged.rb
 - lib/lyp/lilypond.rb
 - lib/lyp/package.rb