public string GetValue(Env env)
{
if (m_strValue == null)
m_strValue = m_value.ToCSS(env);
return m_strValue;
}
public CartoSelector(IEnumerable<Element> elements, Env env)
: base(elements)
{
m_filters = new CartoFilterSet();
m_zooms = new NodeList<CartoZoomElement>();
m_elements = new NodeList<CartoElement>();
m_conditions = 0;
if (env == null)
env = new Env(); // TODO
foreach (Element elem in elements)
{
if (elem is CartoFilterElement)
{
m_filters.Add(elem as CartoFilterElement, env);
m_conditions++;
}
else if (elem is CartoZoomElement)
{
m_zooms.Add(elem as CartoZoomElement);
m_conditions++;
}
else if (elem is CartoAttachmentElement)
m_attachment = (elem as CartoAttachmentElement).Value;
else
m_elements.Add((CartoElement)elem);
}
}
public override Node Evaluate(Env env)
{
return new TextNode(string.Format("[{0}{1}{2}]",
Name.Evaluate(env).ToCSS(env),
Op == null ? "" : Op.Evaluate(env).ToCSS(env),
Value == null ? "" : Value.Evaluate(env).ToCSS(env)));
}
public CartoReaderContext(Env env, ICartoTranslator translator)
{
NodeValues = new Dictionary<int, string>();
Env = env;
Translator = translator;
_lockObj = new object();
}
/// <summary></summary>
/// <param name="env"></param>
/// <returns></returns>
protected override Node Evaluate(Env env)
{
// validate arguments
if (Arguments.Count != 1)
throw new ParserException("The DynamicResourcePathFunction should be invoked with exactly one parameter");
// unescape
Func<Node, string> unescape = n => n is Quoted ? ((Quoted) n).UnescapeContents() : n.ToCSS(env);
// get the path
var relativePath = unescape(Arguments[0]);
// get the web context
var context = DotLessContextHelper.GetContext();
// create the url
var url = Url.CreateUrl(context);
// assemble the path
url.PathSegments = WebUtilities.CombineIntoRelativeUrl(DynamicResourceRequestHandler.Prefix, relativePath);
url.CanHaveExtension = true;
// return the result
return new Quoted(url.ToString(), '\'', false);
}
public bool CanCloneWith(CartoFilterSet other, Env env)
{
int additions = 0;
if (m_filters.Count > 0)
{
foreach (KeyValuePair<string, CartoFilterElement> kv in other.m_filters)
{
string id = kv.Key;
object status = this.Addable(kv.Value, env);
if (status != null)
{
if ((bool)status == false)
{
return true;
}
if ((bool)status == true)
{
additions++;
}
}
}
}
else
{
additions += other.m_filters.Count;
}
return additions > 0;
}
public override Node Evaluate(Env env)
{
if (Condition.Passes(env))
{
return EvaluateRulesForFrame(this, env);
}
return new NodeList();
}
public override Node Evaluate(Env env)
{
env.Frames.Push(this);
Rules = new NodeList(Rules.Select(r => r.Evaluate(env))).ReducedFrom<NodeList>(Rules);
env.Frames.Pop();
return this;
}
public void RegisteringSingleFunctionInDifferentEnvironmentsWorks() {
var env = new Env();
env.AddPlugin(new TestPlugin1());
Assert.DoesNotThrow(() => {
var newEnv = new Env();
newEnv.AddPlugin(new TestPlugin1());
});
}
public CartoFilterElement(Node key, Node op, Node value, Combinator combinator, Env env)
: base(combinator, value)
{
m_key = key;
m_op = op;
m_value = value;
m_id = "[" + m_key.ToString() + "]" + m_op.ToString() + m_value.ToCSS(env).ToString();
}
public CartoDefinition(CartoDefinition def, CartoFilterSet filters, Env env)
{
m_rules = CreateCopy(def.Rules);
m_elements = new NodeList<CartoElement>(def.m_elements);
m_ruleIndex = new List<string>(def.m_ruleIndex);
m_filters = filters != null ? filters : (CartoFilterSet)def.Filters.Clone(env);
m_attachment = def.Attachment;
m_zoom = def.m_zoom;
m_specificity = def.m_specificity;
}
protected override Node Eval(Env env, Node[] list, Node[] args)
{
Guard.ExpectNumArguments(1, args.Length, this, Location);
Guard.ExpectNode<Number>(args[0], this, args[0].Location);
var index = (int)(args[0] as Number).Value;
// Extract function indecies are 1-based
return list[index-1];
}
public override void AppendCSS(Env env, Context context)
{
env.Output.Append(Identifier);
// Append pre comments as we out put each rule ourselves
if (Rules.PreComments)
{
env.Output.Append(Rules.PreComments);
}
AppendRules(env);
}
/// <summary>
/// Removes dead style definitions that can never be reached
/// when filter-mode="first". The style is modified in-place
/// and returned. The style must be sorted.
/// </summary>
public void Fold(Env env)
{
for (int i = 0; i < Definitions.Count; i++)
{
CartoDefinition defI = Definitions[i];
for (int j = Definitions.Count - 1; j > i; j--)
{
// if (Definitions[j].Filters.CloneWith(defI.Filters, env) == null) // Runge: replace with a bit faster version
if (Definitions[j].Filters.CanCloneWith(defI.Filters, env) == false)
Definitions.RemoveAt(j);
}
}
}
public override Node Evaluate(Env env)
{
int minZoom = 0;
int maxZoom = int.MaxValue;
m_zoom = 0;
Node node = m_value.Evaluate(env);
Number number = node as Number;
int value = 0;
if (number != null)
value = Convert.ToInt32(number.ToNumber());
else
value = Convert.ToInt32(node.ToString());
if (value > MAX_ZOOM || value < 0)
throw new Exception(string.Format("Zoom '{0}' level is out of range", value));
string comp = m_comp.ToString();
switch (comp)
{
case "=":
m_zoom = 1 << value;
return this;
case ">":
minZoom = value + 1;
break;
case ">=":
minZoom = value;
break;
case "<":
maxZoom = value - 1;
break;
case "<=":
maxZoom = value;
break;
}
for (var i = 0; i <= MAX_ZOOM; i++)
{
if (i >= minZoom && i <= maxZoom)
{
m_zoom |= (1 << i);
}
}
return base.Evaluate(env);
}
public void AddExtension(Selector selector, Env env)
{
var path = new List<Selector>();
path.Add(selector);
foreach (var f in env.Frames.Skip(1))
{
var partialSelector = f.Selectors.FirstOrDefault();
if (partialSelector != null)
{
path.Add(partialSelector);
}
}
ExtendedBy.Add(new Selector(new[] { new Element(null, path.Select(p => p.ToCSS(env)).Reverse().JoinStrings("").Trim()) }));
}
public override Node Evaluate(Env env)
{
env.Rule = this;
if (Value == null)
{
throw new ParsingException("No value found for rule " + Name, Location);
}
var rule = new CartoRule(Name, Value.Evaluate(env)).ReducedFrom<CartoRule>(this);
rule.IsSemiColonRequired = this.IsSemiColonRequired;
rule.PostNameComments = this.PostNameComments;
env.Rule = null;
return rule;
}
public override Node Evaluate(Env env)
{
var newExact = new List<Selector>();
foreach (var e in Exact)
{
var childContext = env.CreateChildEnv(new Stack<Ruleset>(env.Frames.Reverse()));
e.AppendCSS(childContext);
newExact.Add(new Selector(new []{new Element(e.Elements.First().Combinator,childContext.Output.ToString().Trim())}));
}
var newPartial = new List<Selector>();
foreach (var e in Partial)
{
var childContext = env.CreateChildEnv(new Stack<Ruleset>(env.Frames.Reverse()));
e.AppendCSS(childContext);
newPartial.Add(new Selector(new[] { new Element(e.Elements.First().Combinator, childContext.Output.ToString().Trim()) }));
}
return new Extend(newExact,newPartial);
}
public override Node Evaluate(Env env)
{
var newExact = new List<Selector>();
foreach (var e in Exact)
{
var childContext = env.CreateChildEnv();
e.AppendCSS(childContext);
var selector = new Selector(new []{new Element(e.Elements.First().Combinator,childContext.Output.ToString().Trim())});
selector.IsReference = IsReference;
newExact.Add(selector);
}
var newPartial = new List<Selector>();
foreach (var e in Partial)
{
var childContext = env.CreateChildEnv();
e.AppendCSS(childContext);
var selector = new Selector(new[] { new Element(e.Elements.First().Combinator, childContext.Output.ToString().Trim()) });
selector.IsReference = IsReference;
newPartial.Add(selector);
}
return new Extend(newExact,newPartial) { IsReference = IsReference, Location = Location };
}
public override dotless.Core.Parser.Infrastructure.Nodes.Node Evaluate(dotless.Core.Parser.Infrastructure.Env env)
{
if (!string.IsNullOrEmpty(Unit) && !Contains(all_units, Unit))
{
env.Logger.Error("Invalid unit: '" + Unit + "'");
}
if (!string.IsNullOrEmpty(Unit) && Contains(physical_units, Unit))
{
//if (!env.ppi)
// convert all units to inch
// convert inch to px using ppi
if (!"px".Equals(Unit))
{
Value = (Value / densities[Unit]) * DPI;
//m_unit = "px";
}
Unit = "";
}
return(this);
}
private Selector GenerateExtenderSelector(Env env, List <IEnumerable <Selector> > selectorPath)
{
var context = GenerateExtenderSelector(selectorPath);
return(new Selector(new[] { new Element(null, context.ToCss(env)) }));
}
public object Clone(Env env)
{
CartoDefinition clone = new CartoDefinition(this, null, env);
return clone;
}
public virtual void OnPreVisiting(Env env)
{
}
public virtual void OnPostVisiting(Env env)
{
}
public void OutputMinificationDoesNotBreakMixinCalls()
{
var input = @"
.pull-right > .dropdown-menu {
right: 0;
left: auto;
}
@media (min-width: 768px) {
.navbar-right {
.dropdown-menu {
.pull-right > .dropdown-menu();
}
}
}";
var expected = @"
.pull-right>.dropdown-menu{right:0;left:auto}@media (min-width:768px){.navbar-right .dropdown-menu{right:0;left:auto}}";
DefaultEnv = () => {
var env = new Env();
env.Compress = true;
return env;
};
AssertLess(input, expected);
}
public override Node Evaluate(Env env)
{
var node = (CssFunctionList) Clone();
node.Inner = Inner.Select(i => i.Evaluate(env)).ToList();
return node;
}
public override void AppendCSS(Env env)
{
}
public object Clone(CartoFilterSet filters, Env env)
{
CartoDefinition clone = new CartoDefinition(this, filters, env);
return clone;
}
public void RegisterExtensionsFrom(Env child)
{
_extensions.AddRange(child._extensions);
}
public override void AppendCSS(Env env)
{
env.Output.AppendMany(Inner, " ");
}
public override void AppendCSS(Env env)
{
env.Output.Append(string.Format("{0}({1})", Name, Value.ToCSS(env)));
}
public Selector Selector(NodeList<Element> elements, NodeLocation location, Env env)
{
return new CartoSelector(elements, env) { Location = location };
}
public override Node Evaluate(Env env)
{
var node = (CssFunction)Clone();
node.Value = Value.Evaluate(env);
return node;
}
