private Import(Node path, Value features, ImportOptions option)
{
if (path == null)
throw new ParserException("Imports do not allow expressions");
OriginalPath = path;
Features = features;
ImportOptions = option;
}
private Import(string path, IImporter importer, Value features)
{
if (path == null)
throw new ParserException("Imports do not allow expressions");
Importer = importer;
Path = path;
Features = features;
ImportAction = Importer.Import(this); // it is assumed to be css if it cannot be found as less
}
public override Node Evaluate(Env env)
{
Node returnNode = null;
Value value;
if (Values.Count == 1 && string.IsNullOrEmpty(Important))
returnNode = Values[0].Evaluate(env);
else
{
returnNode = value = new Value(Values.Select(n => n.Evaluate(env)), Important);
value.PreImportantComments = this.PreImportantComments;
}
return returnNode.ReducedFrom<Node>(this);
}
private Import(string path, IImporter importer, Value features)
{
Importer = importer;
Path = path;
Features = features;
if (path.EndsWith(".css"))
{
Css = true;
} else
{
Css = !Importer.Import(this); // it is assumed to be css if it cannot be found as less
if (Css && path.EndsWith(".less"))
{
throw new FileNotFoundException("You are importing a file ending in .less that cannot be found.", path);
}
}
}
public Media Media(NodeList rules, Value features, NodeLocation location)
{
return new Media(features, rules) { Location = location };
}
public Import Import(Quoted path, Value features, ImportOptions option, NodeLocation location)
{
return new Import(path, features, option) { Location = location };
}
/// <summary>
/// Evaluate when you have a media inside another media
/// </summary>
protected Node EvalNested(Env env, Node features, Ruleset ruleset)
{
var path = new NodeList<Media>(env.MediaPath.ToList());
path.Add(this);
NodeList<NodeList> derivedPath = new NodeList<NodeList>();
// Extract the media-query conditions separated with `,` (OR).
for (int i = 0; i < path.Count; i++)
{
Node pathComponent;
Value value = path[i].Features as Value;
if (value != null)
{
pathComponent = value.Values;
}
else
{
pathComponent = path[i].Features;
}
derivedPath.Add((pathComponent as NodeList) ?? new NodeList() { pathComponent });
}
// Trace all permutations to generate the resulting media-query.
//
// (a, b and c) with nested (d, e) ->
// a and d
// a and e
// b and c and d
// b and c and e
NodeList<NodeList> pathWithAnds = new NodeList<NodeList>();
foreach (NodeList node in derivedPath)
{
pathWithAnds.Add(node);
pathWithAnds.Add(new NodeList() { new TextNode("and") });
}
pathWithAnds.RemoveAt(pathWithAnds.Count - 1);
Features = new Value(Permute(pathWithAnds), null);
// Fake a tree-node that doesn't output anything.
return new Ruleset(new NodeList<Selector>(), new NodeList());
}
public Import(Url path, Value features, ImportOptions option)
: this((Node)path, features, option)
{
OriginalPath = path;
Path = path.GetUnadjustedUrl();
}
public Import(Quoted path, Value features, ImportOptions option)
: this((Node)path, features, option)
{
OriginalPath = path;
}
public Import(Url path, IImporter importer, Value features)
: this(path.GetUnadjustedUrl(), importer, features)
{
OriginalPath = path;
}
public Import(Quoted path, IImporter importer, Value features)
: this(path.Value, importer, features)
{
OriginalPath = path;
}
public Import(Quoted path, IImporter importer, Value features, bool isOnce)
: this(path.Value, importer, features, isOnce)
{
OriginalPath = path;
}
public override Node Evaluate(Env env)
{
var found = false;
var closures = env.FindRulesets(Selector);
if(closures == null)
throw new ParsingException(Selector.ToCSS(env).Trim() + " is undefined", Index);
env.Rule = this;
var rules = new NodeList();
if (PreComments)
rules.AddRange(PreComments);
foreach (var closure in closures)
{
var ruleset = closure.Ruleset;
var matchType = ruleset.MatchArguments(Arguments, env);
if (matchType == MixinMatch.ArgumentMismatch)
continue;
found = true;
if (matchType == MixinMatch.GuardFail)
continue;
if (ruleset is MixinDefinition)
{
try
{
var mixin = ruleset as MixinDefinition;
rules.AddRange(mixin.Evaluate(Arguments, env, closure.Context).Rules);
}
catch (ParsingException e)
{
throw new ParsingException(e.Message, e.Index, Index);
}
}
else
{
if (ruleset.Rules != null)
{
var nodes = new NodeList(ruleset.Rules);
NodeHelper.ExpandNodes<MixinCall>(env, nodes);
rules.AddRange(nodes);
}
}
}
if (PostComments)
rules.AddRange(PostComments);
env.Rule = null;
if (!found)
{
var message = String.Format("No matching definition was found for `{0}({1})`",
Selector.ToCSS(env).Trim(),
StringExtensions.JoinStrings(Arguments.Select(a => a.Value.ToCSS(env)), ", "));
throw new ParsingException(message, Index);
}
if (Important)
{
var importantRules = new NodeList();
foreach (Node node in rules)
{
Rule r = node as Rule;
if (r != null)
{
var valueNode = r.Value;
var value = valueNode as Value;
if (value != null)
{
value = new Value(value.Values, "!important").ReducedFrom<Value>(value);
}
else
{
value = new Value(new NodeList() { valueNode }, "!important");
}
importantRules.Add((new Rule(r.Name, value)).ReducedFrom<Rule>(r));
}
else
{
importantRules.Add(node);
}
}
return importantRules;
}
else
{
return rules;
}
}