Added time condition files. not included in project file yet.

Author: Lasse Sjorup

project/UnitTests/Core/Tasks/ConditionalTaskTest.cs

@@ -1,15 +1,12 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
-using System.Text;
 using Exortech.NetReflector;
 using NUnit.Framework;
 using Rhino.Mocks;
 using ThoughtWorks.CruiseControl.Core;
 using ThoughtWorks.CruiseControl.Core.Tasks;
-using ThoughtWorks.CruiseControl.Core.Util;
-using ThoughtWorks.CruiseControl.Remote;
+using ThoughtWorks.CruiseControl.Remote.Parameters;
 
 namespace ThoughtWorks.CruiseControl.UnitTests.Core.Tasks
 {
@@ -19,22 +16,22 @@ public class ConditionalTaskTest
         MockRepository mocks = new MockRepository();
 
         [SetUp]
-        protected void SetUp()
+        protected virtual void SetUp()
         {
         }
 
         [TearDown]
-        protected void TearDown()
+        protected virtual void TearDown()
         {
         }
 
         [TestFixtureSetUp]
-        public void TestFixtureSetup()
+        public virtual void TestFixtureSetup()
         {
         }
 
         [TestFixtureTearDown]
-        public void TestFixtureTearDown()
+        public virtual void TestFixtureTearDown()
         {
         }
 
@@ -91,8 +88,7 @@ public void ConditionalTaskTest_ConditionTrue_RunTask()
             ITask runTask = mocks.StrictMock<ITask>();
             Expect.Call(delegate { runTask.Run(null); }).IgnoreArguments();
             ITask noRunTask = mocks.StrictMock<ITask>();
-            IIntegrationResult ResultMock = IntegrationResultMother.CreateSuccessful(); //mocks.StrictMock<IIntegrationResult>();
-            //Expect.Call(ResultMock.Status).PropertyBehavior().Return(IntegrationStatus.Success).IgnoreArguments().Repeat.Any();
+            IIntegrationResult ResultMock = IntegrationResultMother.CreateSuccessful();
 
             mocks.ReplayAll();
 
@@ -116,10 +112,6 @@ public void ConditionalTaskTest_ConditionFalse_RunElseTask()
             Expect.Call(delegate { runTask.Run(null); }).IgnoreArguments();
             ITask noRunTask = mocks.StrictMock<ITask>();
             IIntegrationResult ResultMock = IntegrationResultMother.CreateSuccessful();
-            //mocks.StrictMock<IIntegrationResult>();
-            //BuildProgressInformation bpi = mocks.StrictMock<BuildProgressInformation>
-            //Expect.Call(ResultMock.Status).PropertyBehavior().Return(IntegrationStatus.Success).IgnoreArguments().Repeat.Any();
-            //Expect.Call(ResultMock.BuildProgressInformation).IgnoreArguments().Return()
             mocks.ReplayAll();
 
             ConditionalTask task = new ConditionalTask();
@@ -155,5 +147,21 @@ public void ConditionalTaskTest_xmlinterface_pass()
             Debug.WriteLine(testXml);
             ConditionalTask result = NetReflector.Read(testXml) as ConditionalTask;
         }
+
+        //[Test]
+        //[Description("DynamicValues Success")]
+        //[Category("Category")]
+        //public void ConditionalTaskTest_DynamicValues_Success()
+        //{
+        //    CommentTask task = new CommentTask();
+        //    task.Message = "$[buildType|DEV]";
+
+        //    IEnumerable<ParameterBase> pardef = null;
+        //    Dictionary<string, string> par = new Dictionary<string, string>();
+        //    par.Add("buildType", "TEST");
+        //    task.ApplyParameters(par, pardef);
+        //    Assert.That(task.Message, Is.EqualTo("TEST"));
+        //}
+
     }
 }

project/core/tasks/Conditions/DateTimeHelpers/TimePeriod.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text.RegularExpressions;
+
+namespace ThoughtWorks.CruiseControl.Core.tasks.Conditions.DateTimeHelpers
+{
+    [DebuggerDisplay("Time period [{FromTime} - {ToTime}] Inverted : {Inverted}")]
+    public class TimePeriod
+    {
+        private static readonly Regex valueSplitter = new Regex(@"^(?<From>\d{1,2}:\d{2})-(?<To>\d{1,2}:\d{2})$");
+
+        private readonly TimeSpan _fromTime;
+        private readonly bool _inverted;
+
+        private readonly TimeSpan _toTime;
+
+        /// <exception cref="System.ArgumentException"><c>ArgumentException</c>.</exception>
+        public TimePeriod(string source)
+        {
+            if (!valueSplitter.IsMatch(source))
+                throw new ArgumentException("Time periods must be in for format '[hour]:[minute]-[hour]:[minute]'");
+
+            Match split = valueSplitter.Match(source);
+
+            _fromTime = Parse(split.Groups["From"].Value);
+            _toTime = Parse(split.Groups["To"].Value);
+
+            if (_fromTime > _toTime)
+            {
+                _inverted = true;
+                TimeSpan tempSpan = _fromTime;
+                _fromTime = _toTime;
+                _toTime = tempSpan;
+            }
+        }
+
+        private TimeSpan FromTime
+        {
+            get
+            {
+                return _fromTime;
+            }
+        }
+
+        private TimeSpan ToTime
+        {
+            get
+            {
+                return _toTime;
+            }
+        }
+
+        private bool Inverted
+        {
+            get
+            {
+                return _inverted;
+            }
+        }
+
+        public static implicit operator string(TimePeriod p)
+        {
+            return p.ToString();
+        }
+
+        public static implicit operator TimePeriod(string s)
+        {
+            return new TimePeriod(s);
+        }
+
+        public static TimePeriod[] ParsePeriods(string periods)
+        {
+            List<TimePeriod> result = new List<TimePeriod>();
+
+            string[] periodArray = periods.Split(',');
+            foreach (string period in periodArray)
+            {
+                result.Add(new TimePeriod(period));
+            }
+
+            return result.ToArray();
+        }
+
+        /// <exception cref="ArgumentException"><c>ArgumentException</c>.</exception>
+        public static TimeSpan Parse(string value)
+        {
+            TimeSpan result;
+            if (!TimeSpan.TryParse(value, out result))
+                if (value == "24:00")
+                    result = new TimeSpan(1, 0, 0, 0);
+                else
+                    throw new ArgumentException("Invalid time specification '" + value + "'");
+            return result;
+        }
+
+        public bool Contained(TimeSpan time)
+        {
+            bool contained = (FromTime.Ticks <= time.Ticks && ToTime.Ticks >= time.Ticks);
+            return Inverted ? !contained : contained;
+        }
+
+        public override string ToString()
+        {
+            TimeSpan to = Inverted ? FromTime : ToTime;
+            TimeSpan from = Inverted ? ToTime : FromTime;
+
+            if (to.Days == 0)
+                return string.Format("{0:D2}:{1:D2}-{2:D2}:{3:D2}", from.Hours, from.Minutes, to.Hours, to.Minutes);
+            
+            return string.Format("{0:D2}:{1:D2}-24:00", from.Hours, from.Minutes);
+        }
+    }
+}

project/core/tasks/Conditions/DateTimeHelpers/TimeToEvaluate.cs

@@ -0,0 +1,11 @@
+namespace ThoughtWorks.CruiseControl.Core.tasks.Conditions.DateTimeHelpers
+{
+    public enum TimeToEvaluate
+    {
+        now,
+        buildStart,
+        buildEnd,
+        firstModification,
+        lastModification
+    }
+}

project/core/tasks/Conditions/DateTimeHelpers/datetimeFunctions.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Text.RegularExpressions;
+
+namespace ThoughtWorks.CruiseControl.Core.tasks.Conditions.DateTimeHelpers
+{
+    public static class DatetimeFunctions
+    {
+        internal static DateTime getTimeInTimeZone(string zone, DateTime time)
+        {
+            TimeSpan offset = getTimeZoneOffset(zone, time);
+            return time.Add(offset);
+        }
+
+        /// <exception cref="ArgumentException">Timezone must be in the format GMT[+|-][hour]:[minute]</exception>
+        public static TimeSpan getTimeZoneOffset(string zone, DateTime time)
+        {
+            if (string.IsNullOrEmpty(zone) || zone.Equals("current", StringComparison.InvariantCultureIgnoreCase)) return new TimeSpan(0);
+
+            TimeSpan baseOffset = new TimeSpan(-TimeZone.CurrentTimeZone.GetUtcOffset(time).Ticks);
+
+            TimeSpan timeZoneOffset = ParseTimeZone(zone);
+            return timeZoneOffset - baseOffset;
+        }
+
+        public static TimeSpan ParseTimeZone(string zone)
+        {
+            Regex timezoneSplitter = new Regex(@"^GMT(?<offset>(?<symbol>[+-])(?<hour>\d{1,2})(:(?<minute>\d{2}))?)?$");
+            if (!timezoneSplitter.IsMatch(zone))
+                throw new ArgumentException("Timezone must be in the format GMT[+|-][hour]:[minute]");
+
+            Match timezone = timezoneSplitter.Match(zone);
+            if (!timezone.Groups["offset"].Success)
+                return new TimeSpan(0); //Only GMT specified
+
+            bool positive = timezone.Groups["symbol"].Value == "+";
+            int hours = 0;
+            int minutes = 0;
+            int.TryParse(timezone.Groups["hour"].Value, out hours);
+            int.TryParse(timezone.Groups["minute"].Value, out minutes);
+
+            if(hours>12)
+                throw new ArgumentException("GMT must be between -12 and +12");
+
+            if(minutes<0 || minutes>59)
+                throw new ArgumentException("Minutes must be between 0 and 59");
+
+            TimeSpan timeZoneOffset = positive ? new TimeSpan(0, hours, minutes, 0) : -new TimeSpan(0, hours, minutes, 0);
+            return timeZoneOffset;
+        }
+    }
+}

project/core/tasks/Conditions/DateTimeHelpers/weekDay.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace ThoughtWorks.CruiseControl.Core.tasks.Conditions.DateTimeHelpers
+{
+    [Flags]
+    public enum WeekDay
+    {
+        None = 0,
+        Monday = 1,
+        Mon = 1,
+        Thusday = 2,
+        Tue = 2,
+        Wednesday = 4,
+        Wed = 4,
+        Thursday = 8,
+        Thu = 8,
+        Friday = 16,
+        Fri = 16,
+        Saturday = 32,
+        Sat = 32,
+        Sunday = 64,
+        Sun = 64,
+
+        Weekend = Sat | Sun,
+        Workweek = Mon | Tue | Wed | Thu | Fri,
+        Any = Weekend | Workweek
+    }
+}

project/core/tasks/Conditions/DateTimeHelpers/weekDayMask.cs

@@ -0,0 +1,79 @@
+using System;
+
+namespace ThoughtWorks.CruiseControl.Core.tasks.Conditions.DateTimeHelpers
+{
+    public class WeekDayMask
+    {
+        private WeekDay mask;
+        public WeekDayMask(string weekdays)
+        {
+            mask = GetWeekDayMask(weekdays);
+        }
+
+        internal static WeekDay GetWeekDayMask(string weekdays)
+        {
+            WeekDay result = WeekDay.None;
+            foreach (string weekday in weekdays.Split(','))
+            {
+                if (weekday.Contains("-"))
+                {
+                    string[] split = weekday.Split('-');
+                    if (split.Length != 2)
+                        throw new ArgumentException("Invalid weekdays string", "weekdays");
+
+                    WeekDay startWeekDay = ParseWeekDay(split[0]);
+                    int startOffset = (int)Math.Log((int)startWeekDay, 2);
+                    int endOffset = (int)Math.Log((int)ParseWeekDay(split[1]), 2);
+                    if (startOffset == endOffset)
+                        result = startWeekDay;
+                    else
+                        if (startOffset < endOffset)
+                            for (int i = startOffset; i <= endOffset; i++)
+                                result = result | (WeekDay)(int)Math.Pow(2, i);
+                        else
+                        {
+                            for (int i = 0; i <= endOffset; i++)
+                                result = result | (WeekDay)(int)Math.Pow(2, i);
+                            for (int i = startOffset; i <= 6; i++)
+                                result = result | (WeekDay)(int)Math.Pow(2, i);
+                        }
+                }
+                else
+                    result = result | ParseWeekDay(weekday);
+            }
+            return result;
+        }
+
+        internal static WeekDay ParseWeekDay(string weekday)
+        {
+            try
+            {
+                return (WeekDay)Enum.Parse(typeof(WeekDay), weekday, true);
+            }
+            catch (Exception exception)
+            {
+                throw new ArgumentException("Unable to parse weekday string '" + weekday + "'", exception);
+            }
+        }
+
+        public override string ToString()
+        {
+            return mask.ToString();
+        }
+
+        public static implicit operator string(WeekDayMask mask)
+        {
+            return mask.ToString();
+        }
+
+        public static implicit operator WeekDayMask(string s)
+        {
+            return new WeekDayMask(s);
+        }
+
+        public bool Contains(WeekDay day)
+        {
+            return ((day & mask) != WeekDay.None);
+        }
+    }
+}