Script for splitting layers in an Inkscape SVG

[lluchs]

Here's another script I wrote and some observations. The script takes an SVG file created with Inkscape and then outputs one SVG for every layer in the original file, with just that layer visible. It obviously requires #700 to work.

filename: rye .args .first .to-file

attr-by-name: fn { tag name } {
	var 'i 0
	while { tag .attr? i |type? = 'void |not } {
		tag .attr? i |when { .second = name } { .return }
		i:: i + 1
	}
	list [ "" "" "" ]
}

layers: private {
	var 'pairs ref [ ]

	reader filename |do-sxml {
		<g> [ .when { .attr-by-name "groupmode" |third = "layer" }
		            { .attr-by-name "id" |third |append! 'pairs ,
					  .attr-by-name "label" |third |append! 'pairs } ] 
	}
	; crashes: dict pairs |print
	dict deref pairs
}

keys layers |for {
	::id
	name:: layers -> id
	export:: filename .to-string .trim\left "%" |replace ".svg" join [ "-" name ".svg" ]
	actions:: join [
		"select-all:layers; "
		"selection-hide; "
		"select-by-id:" id "; "
		"selection-unhide; "
		"select-all; "
		"object-to-path; "
		"select-by-selector:path[style*=marker]; "
		"object-stroke-to-path; "
		"export-filename:" export "; "
		"export-do; "
	]
	print export
	cmd { inkscape --actions ?actions ?filename } |Run
}

Here are my observations or questions:

• Iterating through attributes until attr? returns void is quite tricky. Is there a better way than what I found (while { tag .attr? i |type? = 'void |not })?
• The tag syntax in do-sxml is pretty neat, but then working with XML attributes is not nice at all.
• If you forget the deref in dict deref pairs, you get a panic.
• We need more functions for working with paths.
  • basename, removing or replacing the extension
  • I don't think the % should be included when turning a path into a string.
• Is there no direct way of iterating over dict entries?
• cmd worked as expected here.

[refaktor]

Wow, very nice example and challenge! As I responded in PR ... I also think positional Attr? doesn't make that much sense. For such cases (unknown attributes) Attrs? would make sense, to get all of them. I see I already have Attr? by name in html dialect (builtins_html.go), which is very similar dialect. I will upgrade the sxml with your changes and add this and go through your observations and questions. Great!

[refaktor]

I did some improvements you proposed, will push online. This is the current state. I will still work on this ... it's a great example that exposed many things.

ext: File-ext? filename: rye .args .first .to-file                                                                                                                                                                                            
                                                                                                                                                                                                                                              
layers: private {                                                                                                                                                                                                                             
    ; there is collect-key! but deprecated                                                                                                                                                                                                    
    ; we will have some less imprative solution for collecting                                                                                                                                                                                
    var 'pairs ref [ ]                                                                                                                                                                                                                        
                                                                                                                                                                                                                                              
    Reader probe filename |do-sxml {                                                                                                                                                                                                          
        <g> [ .when { .Attr? "groupmode" |= "layer" }                                                                                                                                                                                         
                    { .Attr? "id" |append! 'pairs ,                                                                                                                                                                                           
                      .Attr? "label" |append! 'pairs } ]                                                                                                                                                                                      
    }                                                                                                                                                                                                                                         
    ; crashes: dict pairs |print ; -- TODO                                                                                                                                                                                                    
    dict deref pairs                                                                                                                                                                                                                          
}                                                                                                                                                                                                                                             
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              
layers .for\kv 'id 'name {                                                                                                                                                                                                                            
    export:: filename .to-string .replace ext join [ "-" name ext ]                                                                                                                                                                           
    actions:: join\with [                                                                                                                                                                                                                     
        "select-all:layers"                                                                                                                                                                                                                   
        "selection-hide"                                                                                                                                                                                                                      
        "select-by-id:" ++ id                                                                                                                                                                                                                 
        "selection-unhide"                                                                                                                                                                                                                    
        "select-all"                                                                                                                                                                                                                          
        "object-to-path"                                                                                                                                                                                                                      
        "select-by-selector:path[style*=marker]"                                                                                                                                                                                              
        "object-stroke-to-path"                                                                                                                                                                                                               
        "export-filename:" ++ export                                                                                                                                                                                                          
        "export-do"                                                                                                                                                                                                                           
    ] "; "                                                                                                                                                                                                                                    
    print export                                                                                                                                                                                                                              
    cmd { inkscape --actions ?actions ?filename } |Run                                                                                                                                                                                        
} 

[refaktor]

@lluchs I'm looking at the code and I'm again impressed, how you are able to use (and implement or fix - cmd sxml) very specific features of Rye. Like when in example above. I really liked it that I could inject the value for condition, and then inject for true block, but I didn't use it that much and didn't think somebody would so soon and without docs also see that possibility. :)

BTW: I posted this example on reddit

[lluchs]

It's really cool how well these functions compose thanks to values injected into these blocks. I originally had assigned names there but realized it's not necessary, which makes the code read very nicely.

The way Rye's builtin types and functions are just thin wrappers around Go makes it pretty easy and intuitive to extend. The disadvantage is of course that everything requires reflection in Go, which makes mistakes likely (e.g., what is a pointer and what isn't).

[refaktor]

You mean the ref/deref and a consequent crash ... for most of Rye dev I didn't need mutable objects. When I hit this wall I decided for this mechanism, but I haven't really had time yet to think about it deeply. So this is still "open design" issue.

But I think we can certanly make it not crash rye. It could return an error if function is expecting derefed value and it got ref and vice versa, another option is taht functions accept both or ref/deref themselves. Frankly ... I'm not sure what is better language-wise at this point also. We need to work with this some more I think. But I will work to make it stabile as it is now.

---

The collector idea now works. Your cool example just keeps on producing new features :) . Something like this used to be hardcoded into function context which was bad and made them heavier. Now it's just specific Rye context and a function.

ext: File-ext? filename: rye .args .first .to-file

layers: use collector {
    Reader probe filename |do-sxml {
        <g> [ .when { .Attr? "groupmode" |= "layer" }
			{ .Attr? "id" |collect! ,
		      .Attr? "label" |collect! } ]
    }
    dict collected?
}

layers .for\kv 'id 'name {
    export:: filename .to-string .replace ext join [ "-" name ext ]
    actions:: join\with [
        "select-all:layers"
        "selection-hide"
        "select-by-id:" ++ id
        "selection-unhide"
        "select-all"
        "object-to-path"
        "select-by-selector:path[style*=marker]"
        "object-stroke-to-path"
        "export-filename:" ++ export
        "export-do"
    ] "; "
    cmd { inkscape --actions ?actions ?filename } |Run
}

Thanks!

[lluchs]

ref/deref is one part, but also from the Go side whether you need to expect a env.List or a *env.List (is that connected?).

Nice, I really like how the script now reads with all these improvements :)

[refaktor]

Yes, in general or at first all Rye values were non-pointers. But to modify a value in-place ... for example with append! you need to use a pointer. So ref / deref was added for these cases. Ref basically just returns a pointer of a value, and deref returns a value of a pointer. I have too many things open right now, and no real vision into this so this will stay for now. But making Rye not crash, but return sensible error with ref will be done.

I like the code too, it has a "flow" and uses full Rye ... you created a nice versatile problem to think about :)