Capturing the resolved SASS parent selector - sass

Question

I'm trying to find a way to capture the resolved parent selector (&) in SASS (running 3.2.3), likely in a mixin.
Unfortunately (and I've found discussion of this on github) the following go-to solution doesn't work:
#mixin append-to-captured-parent($append) {
$selector: "&-#{$append}";
#{$selector} { #content; }
}
.foo {
#include append-to-captured-parent("bar") {
color: blue;
}
}
The desired output being:
.foo .foo-bar { color: blue; }
Are there any hacks or work-arounds that can result in the desired output? As I understand it, this is likely not possible, as the parent selector isn't resolved until the SASS parser has constructed the entire node tree, at which point it encounters &-bar { ... }, on which it dies:
Syntax error: Invalid CSS after "&": expected "{", was "-bar"
Can we trick SASS into resolving this pre-emptively?
Note: I'm more than open to SASS extensions (Ruby libs) that can accomplish this; unfortunately at this time I'm not Ruby-savvy enough to roll my own (I'm working on it though)

Answer 1

Well, I've come up with a work-around, sort of.
This approach merely isolates the intended functionality, and manages it independently of the actual hierarchy.
First, some quick utilities:
#function slice($list, $from, $into) {
$result: ();
#for $index from $from through $into {
$result: append($result, nth($list, $index));
}
#return $result;
}
#function implode($list, $separator) {
$result: nth($list, 1);
#for $index from 2 through length($list) {
$result: #{$result}#{$separator}#{nth($list, $index)};
}
#return $result;
}
Then the guts:
$-class: ();
#function get-class() {
$top: if(length($-class) - 2 < 1, 1, length($-class) - 2);
#return implode(slice($-class, $top, length($-class)), "-");
}
#mixin class($name) {
$-class: append($-class, $name);
.#{get-class()} {
#content;
}
$-class: slice($-class, 1, length($-class) - 1);
}
What happens here is, the "global" variable $-class, maintains a nesting stack with each invocation of the mixin class. It creates a CSS class declaration by imploding the top three names on the stack (this can be modified to the full stack if desired)
So replicating the question's example:
#include class (foo) {
color: red;
#include class (bar) {
color: blue;
}
}
Will produce:
.foo { color: red; }
.foo .foo-bar { color: blue; }
A less trivial example would be:
#include class(list) {
test: "list";
#include class(item) {
test: "item";
#include class(heading) {
test: "heading";
}
#include class(content) {
test: "content";
#include class(graphic) {
test: "graphic";
}
#include class(summary) {
test: "summary";
}
#include class(details) {
test: "details";
}
}
#include class(footing) {
test: "footing";
}
}
}
Producing:
.list { test: "list"; }
.list .list-item { test: "item"; }
.list .list-item .list-item-heading { test: "heading"; }
.list .list-item .list-item-content { test: "content"; }
.list .list-item .list-item-content .item-content-graphic { test: "graphic"; }
.list .list-item .list-item-content .item-content-summary { test: "summary"; }
.list .list-item .list-item-content .item-content-details { test: "details"; }
.list .list-item .list-item-footing { test: "footing"; }