Fix errors in imported files

dotless · Jun 1, 2012 · 099503d · 099503d
1 parent 2ce7e39
commit 099503d
Show file tree

Hide file tree

Showing 43 changed files with 452 additions and 336 deletions.
diff --git a/src/dotless.Core/Exceptions/ParsingException.cs b/src/dotless.Core/Exceptions/ParsingException.cs
@@ -1,24 +1,26 @@
 namespace dotless.Core.Exceptions
 {
     using System;
+    using dotless.Core.Parser;
 
     public class ParsingException : Exception
     {
-        public int Index { get; set; }
-        public int Call { get; set; }
+        public NodeLocation Location { get; set; }
+        public NodeLocation CallLocation { get; set; }
 
-        public ParsingException(string message, int index) : this(message, null, index, 0) {}
+        public ParsingException(string message, NodeLocation location) : this(message, null, location, null) { }
 
-        public ParsingException(string message, int index, int call) : this(message, null, index, call) {}
+        public ParsingException(string message, NodeLocation location, NodeLocation callLocation) : this(message, null, location, callLocation) { }
 
-        public ParsingException(Exception innerException, int index) : this(innerException, index, 0) {}
+        public ParsingException(Exception innerException, NodeLocation location) : this(innerException, location, null) { }
 
-        public ParsingException(Exception innerException, int index, int call) : this(innerException.Message, innerException, index, call) {}
+        public ParsingException(Exception innerException, NodeLocation location, NodeLocation callLocation) : this(innerException.Message, innerException, location, callLocation) { }
 
-        public ParsingException(string message, Exception innerException, int index, int call) : base(message, innerException)
+        public ParsingException(string message, Exception innerException, NodeLocation location, NodeLocation callLocation)
+            : base(message, innerException)
         {
-          Index = index;
-          Call = call;
+            Location = location;
+            CallLocation = callLocation;
         }
     }
 }
diff --git a/src/dotless.Core/Parser/Functions/AddFunction.cs b/src/dotless.Core/Parser/Functions/AddFunction.cs
@@ -10,7 +10,7 @@ public class AddFunction : Function
     {
         protected override Node Evaluate(Env env)
         {
-            Guard.ExpectAllNodes<Number>(Arguments, this, Index);
+            Guard.ExpectAllNodes<Number>(Arguments, this, Location);
 
             var value = Arguments.Cast<Number>().Select(d => d.Value).Aggregate(0d, (a, b) => a + b);
 

diff --git a/src/dotless.Core/Parser/Functions/ColorFunction.cs b/src/dotless.Core/Parser/Functions/ColorFunction.cs
@@ -9,8 +9,8 @@ public class ColorFunction : Function
     {
         protected override Node Evaluate(Env env)
         {
-            Guard.ExpectNumArguments(1, Arguments.Count, this, Index);
-            Guard.ExpectNode<TextNode>(Arguments[0], this, Index);
+            Guard.ExpectNumArguments(1, Arguments.Count, this, Location);
+            Guard.ExpectNode<TextNode>(Arguments[0], this, Location);
 
             return new Color(((TextNode)Arguments[0]).Value.TrimStart('#'));
         }

diff --git a/src/dotless.Core/Parser/Functions/ColorFunctionBase.cs b/src/dotless.Core/Parser/Functions/ColorFunctionBase.cs
@@ -10,14 +10,14 @@ public abstract class ColorFunctionBase : Function
     {
         protected override Node Evaluate(Env env)
         {
-            Guard.ExpectMinArguments(1, Arguments.Count(), this, Index);
-            Guard.ExpectNode<Color>(Arguments[0], this, Arguments[0].Index);
+            Guard.ExpectMinArguments(1, Arguments.Count(), this, Location);
+            Guard.ExpectNode<Color>(Arguments[0], this, Arguments[0].Location);
 
             var color = Arguments[0] as Color;
 
             if (Arguments.Count == 2)
             {
-                Guard.ExpectNode<Number>(Arguments[1], this, Arguments[1].Index);
+                Guard.ExpectNode<Number>(Arguments[1], this, Arguments[1].Location);
 
                 var number = Arguments[1] as Number;
                 var edit = EditColor(color, number);

diff --git a/src/dotless.Core/Parser/Functions/ContrastFunction.cs b/src/dotless.Core/Parser/Functions/ContrastFunction.cs
@@ -10,18 +10,18 @@ public class ContrastFunction : Function
     {
         protected override Node Evaluate(Env env)
         {
-            Guard.ExpectMinArguments(1, Arguments.Count, this, Index);
-            Guard.ExpectMaxArguments(4, Arguments.Count, this, Index);
-            Guard.ExpectNode<Color>(Arguments[0], this, Index);
+            Guard.ExpectMinArguments(1, Arguments.Count, this, Location);
+            Guard.ExpectMaxArguments(4, Arguments.Count, this, Location);
+            Guard.ExpectNode<Color>(Arguments[0], this, Location);
 
             var color = HslColor.FromRgbColor((Color) Arguments[0]);
 
             if (Arguments.Count > 1)
-              Guard.ExpectNode<Color>(Arguments[1], this, Index);
+                Guard.ExpectNode<Color>(Arguments[1], this, Location);
             if (Arguments.Count > 2)
-              Guard.ExpectNode<Color>(Arguments[2], this, Index);
+                Guard.ExpectNode<Color>(Arguments[2], this, Location);
             if (Arguments.Count > 3)
-              Guard.ExpectNode<Number>(Arguments[3], this, Index);
+                Guard.ExpectNode<Number>(Arguments[3], this, Location);
 
             WarnNotSupportedByLessJS("contrast(color, color[, color[, percentage]])");
 

diff --git a/src/dotless.Core/Parser/Functions/Function.cs b/src/dotless.Core/Parser/Functions/Function.cs
@@ -11,14 +11,14 @@ public abstract class Function
         public string Name { get; set; }
         protected List<Node> Arguments { get; set; }
         public ILogger Logger { get; set; }
-        public int Index { get; set; }
+        public NodeLocation Location { get; set; }
 
         public Node Call(Env env, IEnumerable<Node> arguments)
         {
             Arguments = arguments.ToList();
 
             var node = Evaluate(env);
-            node.Index = Index;
+            node.Location = Location;
             return node;
         }
 

diff --git a/src/dotless.Core/Parser/Functions/HexFunction.cs b/src/dotless.Core/Parser/Functions/HexFunction.cs
@@ -12,7 +12,7 @@ protected override Node Eval(Env env, Number number, Node[] args)
             WarnNotSupportedByLessJS("hex(number)");
 
             if (!string.IsNullOrEmpty(number.Unit))
-                throw new ParsingException(string.Format("Expected unitless number in function 'hex', found {0}", number.ToCSS(env)), number.Index);
+                throw new ParsingException(string.Format("Expected unitless number in function 'hex', found {0}", number.ToCSS(env)), number.Location);
 
             number.Value = Clamp(number.Value, 255, 0);
 

diff --git a/src/dotless.Core/Parser/Functions/HslFunction.cs b/src/dotless.Core/Parser/Functions/HslFunction.cs
@@ -9,7 +9,7 @@ public class HslFunction : HslaFunction
     {
         protected override Node Evaluate(Env env)
         {
-            Guard.ExpectNumArguments(3, Arguments.Count, this, Index);
+            Guard.ExpectNumArguments(3, Arguments.Count, this, Location);
 
             Arguments.Add(new Number(1d, ""));
 

diff --git a/src/dotless.Core/Parser/Functions/HslaFunction.cs b/src/dotless.Core/Parser/Functions/HslaFunction.cs
@@ -10,8 +10,8 @@ public class HslaFunction : Function
     {
         protected override Node Evaluate(Env env)
         {
-            Guard.ExpectNumArguments(4, Arguments.Count, this, Index);
-            Guard.ExpectAllNodes<Number>(Arguments, this, Index);
+            Guard.ExpectNumArguments(4, Arguments.Count, this, Location);
+            Guard.ExpectAllNodes<Number>(Arguments, this, Location);
 
             var args = Arguments.Cast<Number>().ToArray();
 

diff --git a/src/dotless.Core/Parser/Functions/IsFunctions.cs b/src/dotless.Core/Parser/Functions/IsFunctions.cs
@@ -12,7 +12,7 @@ public abstract class IsFunction : Function
     {
         protected override Infrastructure.Nodes.Node Evaluate(Infrastructure.Env env)
         {
-            Guard.ExpectNumArguments(1, Arguments.Count, this, Index);
+            Guard.ExpectNumArguments(1, Arguments.Count, this, Location);
 
             return new Keyword(IsEvaluator(Arguments[0]) ? "true" : "false");
         }

diff --git a/src/dotless.Core/Parser/Functions/MixFunction.cs b/src/dotless.Core/Parser/Functions/MixFunction.cs
@@ -10,14 +10,14 @@ public class MixFunction : Function
     {
         protected override Node Evaluate(Env env)
         {
-            Guard.ExpectMinArguments(2, Arguments.Count, this, Index);
-            Guard.ExpectMaxArguments(3, Arguments.Count, this, Index);
-            Guard.ExpectAllNodes<Color>(Arguments.Take(2), this, Index);
+            Guard.ExpectMinArguments(2, Arguments.Count, this, Location);
+            Guard.ExpectMaxArguments(3, Arguments.Count, this, Location);
+            Guard.ExpectAllNodes<Color>(Arguments.Take(2), this, Location);
 
             double weight = 50;
             if (Arguments.Count == 3)
             {
-                Guard.ExpectNode<Number>(Arguments[2], this, Index);
+                Guard.ExpectNode<Number>(Arguments[2], this, Location);
 
                 weight = ((Number) Arguments[2]).Value;
             }

diff --git a/src/dotless.Core/Parser/Functions/NumberFunctionBase.cs b/src/dotless.Core/Parser/Functions/NumberFunctionBase.cs
@@ -10,8 +10,8 @@ public abstract class NumberFunctionBase : Function
     {
         protected override Node Evaluate(Env env)
         {
-            Guard.ExpectMinArguments(1, Arguments.Count, this, Index);
-            Guard.ExpectNode<Number>(Arguments[0], this, Arguments[0].Index);
+            Guard.ExpectMinArguments(1, Arguments.Count, this, Location);
+            Guard.ExpectNode<Number>(Arguments[0], this, Arguments[0].Location);
 
             var number = Arguments[0] as Number;
             var args = Arguments.Skip(1).ToArray();

diff --git a/src/dotless.Core/Parser/Functions/PercentageFunction.cs b/src/dotless.Core/Parser/Functions/PercentageFunction.cs
@@ -15,7 +15,7 @@ protected override Node Eval(Env env, Number number, Node[] args)
             if (string.IsNullOrEmpty(number.Unit))
                 return new Number(number.Value * 100, "%");
 
-            throw new ParsingException(string.Format("Expected unitless number in function 'percentage', found {0}", number.ToCSS(env)), number.Index);
+            throw new ParsingException(string.Format("Expected unitless number in function 'percentage', found {0}", number.ToCSS(env)), number.Location);
         }
     }
 }
diff --git a/src/dotless.Core/Parser/Functions/PowFunction.cs b/src/dotless.Core/Parser/Functions/PowFunction.cs
@@ -11,9 +11,9 @@ public class PowFunction : Function
     {
         protected override Node Evaluate(Env env)
         {
-            Guard.ExpectMinArguments(2, Arguments.Count, this, Index);
-            Guard.ExpectMaxArguments(2, Arguments.Count, this, Index);
-            Guard.ExpectAllNodes<Number>(Arguments, this, Index);
+            Guard.ExpectMinArguments(2, Arguments.Count, this, Location);
+            Guard.ExpectMaxArguments(2, Arguments.Count, this, Location);
+            Guard.ExpectAllNodes<Number>(Arguments, this, Location);
 
             WarnNotSupportedByLessJS("pow(number, number)");
 

diff --git a/src/dotless.Core/Parser/Functions/RgbFunction.cs b/src/dotless.Core/Parser/Functions/RgbFunction.cs
@@ -9,7 +9,7 @@ public class RgbFunction : RgbaFunction
     {
         protected override Node Evaluate(Env env)
         {
-            Guard.ExpectNumArguments(3, Arguments.Count, this, Index);
+            Guard.ExpectNumArguments(3, Arguments.Count, this, Location);
 
             Arguments.Add(new Number(1d, ""));
 

diff --git a/src/dotless.Core/Parser/Functions/RgbaFunction.cs b/src/dotless.Core/Parser/Functions/RgbaFunction.cs
@@ -12,14 +12,14 @@ protected override Node Evaluate(Env env)
         {
             if (Arguments.Count == 2)
             {
-                Guard.ExpectNode<Color>(Arguments[0], this, Index);
-                Guard.ExpectNode<Number>(Arguments[1], this, Index);
+                Guard.ExpectNode<Color>(Arguments[0], this, Location);
+                Guard.ExpectNode<Number>(Arguments[1], this, Location);
 
                 return new Color(((Color) Arguments[0]).RGB, ((Number) Arguments[1]).Value);
             }
 
-            Guard.ExpectNumArguments(4, Arguments.Count, this, Index);
-            Guard.ExpectAllNodes<Number>(Arguments, this, Index);
+            Guard.ExpectNumArguments(4, Arguments.Count, this, Location);
+            Guard.ExpectAllNodes<Number>(Arguments, this, Location);
 
             var args = Arguments.Cast<Number>();
 

diff --git a/src/dotless.Core/Parser/Functions/StringFunctions.cs b/src/dotless.Core/Parser/Functions/StringFunctions.cs
@@ -13,7 +13,7 @@ public class EFunction : Function
     {
         protected override Node Evaluate(Env env)
         {
-            Guard.ExpectMaxArguments(1, Arguments.Count, this, Index);
+            Guard.ExpectMaxArguments(1, Arguments.Count, this, Location);
 
             WarnNotSupportedByLessJS("e(string)", @"~""""");