public void BackreferencesAreMergedWithMappings()
{
var stream = Yaml.StreamFrom("backreference.yaml");
var parser = new MergingParser(new Parser(stream));
var result = Deserializer.Deserialize<Dictionary<string, Dictionary<string, string>>>(new EventReader(parser));
var alias = result["alias"];
alias.Should()
.Contain("key1", "value1", "key1 should be inherited from the backreferenced mapping")
.And.Contain("key2", "Overriding key2", "key2 should be overriden by the actual mapping")
.And.Contain("key3", "value3", "key3 is defined in the actual mapping");
}
public void MergingDoesNotProduceDuplicateAnchors()
{
var parser = new MergingParser(Yaml.ParserForText(@"
anchor: &default
key1: &myValue value1
key2: value2
alias:
<<: *default
key2: Overriding key2
key3: value3
useMyValue:
key: *myValue
"));
var result = Deserializer.Deserialize<Dictionary<string, Dictionary<string, string>>>(new EventReader(parser));
var alias = result["alias"];
alias.Should()
.Contain("key1", "value1", "key1 should be inherited from the backreferenced mapping")
.And.Contain("key2", "Overriding key2", "key2 should be overriden by the actual mapping")
.And.Contain("key3", "value3", "key3 is defined in the actual mapping");
result["useMyValue"].Should()
.Contain("key", "value1", "key should be copied");
}
public void ExampleFromSpecificationIsHandledCorrectly()
{
var parser = new MergingParser(Yaml.ParserForText(@"
obj:
- &CENTER { x: 1, y: 2 }
- &LEFT { x: 0, y: 2 }
- &BIG { r: 10 }
- &SMALL { r: 1 }
# All the following maps are equal:
results:
- # Explicit keys
x: 1
y: 2
r: 10
label: center/big
- # Merge one map
<< : *CENTER
r: 10
label: center/big
- # Merge multiple maps
<< : [ *CENTER, *BIG ]
label: center/big
- # Override
#<< : [ *BIG, *LEFT, *SMALL ] # This does not work because, in the current implementation,
# later keys override former keys. This could be fixed, but that
# is not trivial because the deserializer allows aliases to refer to
# an anchor that is defined later in the document, and the way it is
# implemented, the value is assigned later when the anchored value is
# deserialized.
<< : [ *SMALL, *LEFT, *BIG ]
x: 1
label: center/big
"));
var result = Deserializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(new EventReader(parser));
int index = 0;
foreach (var mapping in result["results"])
{
mapping.Should()
.Contain("x", "1", "'x' should be '1' in result #{0}", index)
.And.Contain("y", "2", "'y' should be '2' in result #{0}", index)
.And.Contain("r", "10", "'r' should be '10' in result #{0}", index)
.And.Contain("label", "center/big", "'label' should be 'center/big' in result #{0}", index);
++index;
}
}
public static Map ReadFromFile(string fileContent, string fileName)
{
string path = Path.GetDirectoryName(fileName);
CartoProject cartoProject = null;
switch (Path.GetExtension(fileName).ToLower())
{
case ".mml":
cartoProject = JsonConvert.DeserializeObject<CartoProject>(fileContent);
if (cartoProject.Interactivity != null)
{
try
{
Dictionary<string, object> dict = JsonConvert.DeserializeObject<Dictionary<string, object>>(cartoProject.Interactivity.ToString());
cartoProject.Interactivity = dict;
}
catch
{ }
try
{
bool enabled = JsonConvert.DeserializeObject<bool>(cartoProject.Interactivity.ToString());
cartoProject.Interactivity = enabled;
}
catch
{ }
}
break;
case ".yaml":
using (StringReader input = new StringReader(fileContent))
{
Deserializer deserializer = new Deserializer(namingConvention: new CamelCaseNamingConvention(), ignoreUnmatched: true);
var parser = new MergingParser(new YamlDotNet.Core.Parser(input));
cartoProject = deserializer.Deserialize<CartoProject>(new EventReader(parser));
}
break;
default:
throw new Exception("Unknown extension of the CartoCSS project.");
}
Map map = null;
if (cartoProject.Stylesheet != null && cartoProject.Stylesheet.Length > 0 && cartoProject.Layers.Length > 0)
{
ICartoTranslator cartoTranslator = CartoGeneratorConverterFactory.CreateTranslator(cartoProject.Generator);
CartoParser parser = new CartoParser();
parser.NodeProvider = new CartoNodeProvider();
Env env = new Env();
List<Ruleset> ruleSets = new List<Ruleset>();
List<CartoDefinition> definitions = new List<CartoDefinition>();
foreach (string styleName in cartoProject.Stylesheet)
{
string styleFileName = Path.Combine(path, styleName);
try
{
Ruleset ruleSet = parser.Parse(File.ReadAllText(styleFileName), styleFileName, env);
ruleSets.Add(ruleSet);
// Get an array of Ruleset objects, flattened
// and sorted according to specificitySort
var defs = new List<CartoDefinition>();
defs = ruleSet.Flatten(defs, null, env);
defs.Sort(new SpecificitySorter());
definitions.AddRange(defs);
env.Frames.Push(ruleSet);
}
catch (Exception ex)
{
Exception ex2 = new IOException(string.Format("An error occured during parsing of the style '{0}'.", styleFileName) + ex.Message);
LogFactory.WriteLogEntry(Logger.Default, ex2);
throw ex2;
}
}
string interactivityLayer = null;
if (cartoProject.GetInteractivity() != null && cartoProject.GetInteractivity().ContainsKey("layer"))
interactivityLayer = cartoProject.GetInteractivity()["layer"].ToString();
map = CreateMap(cartoProject, definitions, env, cartoTranslator);
foreach (CartoLayer cartoLayer in cartoProject.Layers)
{
CartoDatasource datasource = cartoLayer.Datasource;
StyledLayer styledLayer = CreateStyledLayer(cartoLayer, map, cartoTranslator);
try
{
string[] classes = (cartoLayer.Class.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries));
Dictionary<string, bool> classIndex = new Dictionary<string, bool>(classes.Length);
for (int i = 0; i < classes.Length; i++)
classIndex[classes[i]] = true;
var matching = definitions.FindAll(delegate (CartoDefinition def) { return def.AppliesTo(cartoLayer.Name, classIndex); });
if (matching.Count > 0)
{
List<CartoStyle> rules = InheritDefinitions(matching, env);
if (rules.Count > 0)
{
SortStyles(rules, env);
for (int k = 0; k < rules.Count; k++)
{
CartoStyle cartoStyle = rules[k];
cartoStyle.Fold(env);
string styleName = cartoLayer.Name + (cartoStyle.Attachment != "__default__" ? "-" + cartoStyle.Attachment : "");
FeatureTypeStyle style = CreateStyle(styleName, cartoStyle, env, cartoTranslator);
if (style.Rules.Count > 0)
styledLayer.Styles.Add(style);
}
cartoTranslator.ProcessStyles(styledLayer.Styles);
}
if (!string.IsNullOrEmpty(interactivityLayer) && interactivityLayer.Equals(styledLayer.Name))
styledLayer.Enabled = false;
map.AddLayer(styledLayer);
}
}
catch (Exception ex)
{
Exception ex2 = new IOException(string.Format("Unable to create data source provider with type '{0}' for the layer '{1}'.", datasource.Type, cartoLayer.Name) + ex.Message);
LogFactory.WriteLogEntry(Logger.Default, ex2);
}
}
}
return map;
}
