Initial release

– implement packing
– improve code
– improve cli

Author: florianpircher

Cargo.toml

@@ -1,14 +1,19 @@
 [package]
 name = "glyphspack"
-version = "0.1.0"
+version = "1.0.0"
 authors = ["Florian Pircher <florian@addpixel.net>"]
 edition = "2018"
 description = "Convert between .glyphs and .glyphspackage files."
 license = "MIT OR Apache-2.0"
 
 [dependencies]
 anyhow = "1.0"
-clap = "2.33.3"
 pest = "2.1.3"
 pest_derive = "2.1.0"
 rayon = "1.5.1"
+regex = "1.5.4"
+
+[dependencies.clap]
+version = "2.33.3"
+default-features = false
+features = [ "suggestions", "wrap_help" ]

README.md

@@ -1,6 +1,26 @@
 # glyphspack
 
-Convert between .glyphs and .glyphspackage files.
+`glyphspack` converts between the  `.glyphs` and `.glyphspackage` file format flavors of the [Glyphs font editor](https://glyphsapp.com).
+
+In Glyphs, save a file to a different format with _File_ → _Save As…_ → _File Format_.
+
+## Usage
+
+```sh
+$ glyphspack SomeFont.glyphspackage
+Unpacking SomeFont.glyphspackage into SomeFont.glyphs.
+$ glyphspack OtherFont.glyphs
+Packing OtherFont.glyphs into OtherFont.glyphspackage.
+```
+
+Options:
+
+- Set the output file name with `-o`/`--out`.
+- Overwrite any existing files with `-f`/`--force`.
+- Suppress log messages with `-q`/`--quiet`.
+- Print the path of the exported file to stdout with `-p`/`--print-path`.
+
+Run with `--help` for a complete parameter description.
 
 ## License
 

src/main.rs

@@ -1,5 +1,7 @@
-use anyhow::{bail, Result};
+use anyhow::{bail, Context, Result};
 use clap::{App, Arg};
+use std::io::Write;
+use std::os::unix::prelude::OsStrExt;
 use std::path::Path;
 
 #[macro_use]
@@ -9,45 +11,80 @@ mod pack;
 mod plist;
 mod unpack;
 
+const ARG_KEY_OUTFILE: &str = "OUT";
+const ARG_KEY_FILE: &str = "IN";
+const ARG_KEY_FORCE: &str = "FORCE";
+const ARG_KEY_QUIET: &str = "QUIET";
+const ARG_KEY_PRINT_PATH: &str = "PRINTPATH";
+
+const FILE_EXT_STANDALONE: &str = "glyphs";
+const FILE_EXT_PACKAGE: &str = "glyphspackage";
+const FILE_EXT_GLYPH: &str = "glyph";
+
+const FILE_PACKAGE_FONTINFO: &str = "fontinfo.plist";
+const FILE_PACKAGE_ORDER: &str = "order.plist";
+const FILE_PACKAGE_UI_STATE: &str = "UIState.plist";
+const FILE_PACKAGE_GLYPHS: &str = "glyphs";
+
+const KEY_DISPLAY_STRINGS_PACKAGE: &str = "displayStrings";
+const KEY_DISPLAY_STRINGS_STANDALONE: &str = "DisplayStrings";
+const KEY_GLYPH_NAME: &str = "glyphname";
+const KEY_GLYPHS: &str = "glyphs";
+
 enum Operation {
     Pack,
     Unpack,
 }
 
 fn main() -> Result<()> {
     let config = App::new("glyphspack")
-        .version("0.2")
+        .version("1.0")
         .author("Florian Pircher <florian@addpixel.net>")
-        .about("Convert between .glyphs and .glyphspackage files.")
+        .about("Convert between .glyphs and .glyphspackage files. The conversion direction is automatically detected depending on whether <FILE> is a directory or not.")
+        .after_help("See the Glyphs Handbook <https://glyphsapp.com/learn> for details on the standalone and the package format flavors.")
         .arg(
-            Arg::with_name("OUT")
+            Arg::with_name(ARG_KEY_OUTFILE)
                 .short("o")
                 .long("out")
                 .help("The output file")
                 .value_name("OUTFILE")
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name("FORCE")
+            Arg::with_name(ARG_KEY_FORCE)
                 .short("f")
                 .long("force")
-                .help("Overwrite output file if it already exists"),
+                .help("Overwrites output file if it already exists"),
+        )
+        .arg(
+            Arg::with_name(ARG_KEY_QUIET)
+                .short("q")
+                .long("quiet")
+                .help("Suppresses log messages"),
+        )
+        .arg(
+            Arg::with_name(ARG_KEY_PRINT_PATH)
+                .short("p")
+                .long("print-path")
+                .help("Prints the path of the exported file to stdout"),
         )
         .arg(
-            Arg::with_name("IN")
+            Arg::with_name(ARG_KEY_FILE)
                 .help("The input file")
                 .value_name("FILE")
                 .required(true)
                 .index(1),
         )
         .get_matches();
-    let force = config.is_present("FORCE");
-    let out_file = config.value_of("OUT");
-    let in_file = config.value_of("IN").unwrap();
+    let force = config.is_present(ARG_KEY_FORCE);
+    let quiet = config.is_present(ARG_KEY_QUIET);
+    let print_path = config.is_present(ARG_KEY_PRINT_PATH);
+    let out_file = config.value_of(ARG_KEY_OUTFILE);
+    let in_file = config.value_of(ARG_KEY_FILE).unwrap();
     let in_path = Path::new(in_file);
 
     if !in_path.exists() {
-        bail!("FILE does not exist {}", in_path.display());
+        bail!("<FILE> does not exist: {}", in_path.display());
     }
 
     let operation = if in_path.is_dir() {
@@ -59,17 +96,37 @@ fn main() -> Result<()> {
     let out_path = match out_file {
         Some(file) => Path::new(file).to_owned(),
         None => match operation {
-            Operation::Pack => in_path.with_extension("glyphspackage"),
-            Operation::Unpack => in_path.with_extension("glyphs"),
+            Operation::Pack => in_path.with_extension(FILE_EXT_PACKAGE),
+            Operation::Unpack => in_path.with_extension(FILE_EXT_STANDALONE),
         },
     };
 
     if !force && out_path.exists() {
-        bail!("OUTFILE already exists {}", out_path.display());
+        bail!("<OUTFILE> already exists: {}", out_path.display());
+    }
+
+    if print_path {
+        std::io::stdout()
+            .write_all(out_path.as_os_str().as_bytes())
+            .with_context(|| format!("cannot write path of OUTFILE: {}", out_path.display()))?;
     }
 
     match operation {
-        Operation::Pack => pack::pack(in_path, &out_path),
-        Operation::Unpack => unpack::unpack(in_path, &out_path),
+        Operation::Pack => {
+            if !quiet {
+                eprintln!("Packing {} into {}.", in_path.display(), out_path.display());
+            }
+            pack::pack(in_path, &out_path, force)
+        }
+        Operation::Unpack => {
+            if !quiet {
+                eprintln!(
+                    "Unpacking {} into {}.",
+                    in_path.display(),
+                    out_path.display()
+                );
+            }
+            unpack::unpack(in_path, &out_path)
+        }
     }
 }

src/pack.rs

@@ -1,7 +1,137 @@
-use anyhow::Result;
+use anyhow::{bail, Context, Result};
+use rayon::prelude::*;
+use regex::{Captures, Regex};
+use std::fs;
 use std::path::Path;
 
-pub fn pack(in_path: &Path, out_path: &Path) -> Result<()> {
-    eprintln!("Packing {} into {}.", in_path.display(), out_path.display());
+use crate::{
+    plist, FILE_EXT_GLYPH, FILE_PACKAGE_FONTINFO, FILE_PACKAGE_GLYPHS, FILE_PACKAGE_ORDER,
+    FILE_PACKAGE_UI_STATE, KEY_DISPLAY_STRINGS_PACKAGE, KEY_DISPLAY_STRINGS_STANDALONE, KEY_GLYPHS,
+    KEY_GLYPH_NAME,
+};
+
+pub fn pack(in_path: &Path, out_path: &Path, force: bool) -> Result<()> {
+    // Read Standalong File
+
+    let standalone_code = fs::read_to_string(&in_path)
+        .with_context(|| format!("cannot read font info at {}", in_path.display()))?;
+    let standalone = plist::parse(plist::Root::Dict, &standalone_code)
+        .with_context(|| format!("cannot parse font info at {}", in_path.display()))?;
+    let standalone = match standalone.value {
+        plist::Value::Dict(x) => x,
+        _ => unreachable!(),
+    };
+
+    let mut fontinfo: Vec<&str> = Vec::new();
+    let mut order: Vec<&str> = Vec::new();
+    let mut ui_state: Vec<String> = Vec::new();
+    let mut glyphs: Vec<(&str, &str)> = Vec::new();
+
+    for (key, slice, code) in standalone {
+        match key {
+            KEY_DISPLAY_STRINGS_STANDALONE => {
+                let code = format!("{} = (\n{}\n);", KEY_DISPLAY_STRINGS_PACKAGE, slice.code);
+                ui_state.push(code);
+            }
+            KEY_GLYPHS => {
+                let glyph_slices = match slice.value {
+                    plist::Value::Array(items) => items,
+                    _ => bail!("non-array `{}` in {}", KEY_GLYPHS, in_path.display()),
+                };
+                for glyph_slice in glyph_slices {
+                    let glyph = match glyph_slice.value {
+                        plist::Value::Dict(pairs) => pairs,
+                        _ => bail!("non-dict glyph in {}", in_path.display()),
+                    };
+                    let mut glyph_name: Option<&str> = None;
+                    for (key, slice, _) in glyph {
+                        if key == KEY_GLYPH_NAME {
+                            match slice.value {
+                                plist::Value::String(name) => glyph_name = Some(name),
+                                _ => bail!(
+                                    "non-string `{}` in {}",
+                                    KEY_GLYPH_NAME,
+                                    in_path.display()
+                                ),
+                            };
+                        }
+                    }
+                    let glyph_name = glyph_name.with_context(|| {
+                        format!(
+                            "missing `{}` in glyph in {}",
+                            KEY_GLYPH_NAME,
+                            in_path.display()
+                        )
+                    })?;
+
+                    order.push(glyph_name);
+                    glyphs.push((glyph_name, glyph_slice.code));
+                }
+            }
+            _ => {
+                fontinfo.push(code);
+            }
+        }
+    }
+
+    // Create Directories
+
+    if force && out_path.is_dir() {
+        fs::remove_dir_all(&out_path).with_context(|| {
+            format!(
+                "cannot overwrite existing directory at {}",
+                out_path.display()
+            )
+        })?;
+    }
+
+    fs::create_dir_all(&out_path)
+        .with_context(|| format!("cannot create package at {}", out_path.display()))?;
+
+    let glyphs_path = out_path.join(FILE_PACKAGE_GLYPHS);
+    fs::create_dir(&glyphs_path).with_context(|| {
+        format!(
+            "cannot create glyphs diractory at {}",
+            glyphs_path.display()
+        )
+    })?;
+
+    // Write Font Info
+
+    let fontinfo_path = out_path.join(FILE_PACKAGE_FONTINFO);
+    plist::write_dict_file(&fontinfo_path, &fontinfo)?;
+
+    // Write Order
+
+    let order_path = out_path.join(FILE_PACKAGE_ORDER);
+    plist::write_array_file(&order_path, &order)?;
+
+    // Write UI State
+
+    if !ui_state.is_empty() {
+        let ui_state_path = out_path.join(FILE_PACKAGE_UI_STATE);
+        plist::write_dict_file(&ui_state_path, &ui_state.iter().map(|x| &**x).collect())?;
+    }
+
+    // Write Glyphs
+
+    let init_dot_regex = Regex::new(r"^\.").unwrap();
+    let capital_regex = Regex::new(r"[A-Z]").unwrap();
+
+    glyphs.into_par_iter().try_for_each(|(glyphname, code)| {
+        let file_stem = glyphname;
+        let file_stem = init_dot_regex.replacen(file_stem, 1, "_");
+        let file_stem = capital_regex.replace_all(file_stem.as_ref(), |captures: &Captures| {
+            format!(
+                "{}_",
+                captures.get(0).unwrap().as_str().to_ascii_uppercase()
+            )
+        });
+
+        let glyph_path = glyphs_path.join(format!("{}.{}", file_stem, FILE_EXT_GLYPH));
+        plist::write_dict_file(&glyph_path, &vec![code])?;
+        Ok::<(), anyhow::Error>(())
+    })?;
+
     Ok(())
 }