GothenburgBitFactory/timewarrior
1
0
Fork 0
mirror of https://github.com/GothenburgBitFactory/timewarrior.git synced 2025-07-07 20:06:39 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

data: Broke out inclusion/exclusion code from helper.cpp

Browse source
This commit is contained in:
Paul Beckingham 2016-04-28 20:02:31 -04:00
parent 34c0cc81e7
commit 8ebf25cb01
4 changed files with 436 additions and 192 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/CMakeLists.txt
View file

@ -15,7 +15,7 @@ set (timew_SRCS CLI.cpp CLI.h
Palette.cpp Palette.h
Range.cpp Range.h
Rules.cpp Rules.h
Timeline.cpp Timeline.h
data.cpp
init.cpp
helper.cpp
util.cpp)

136
src/Timeline.cpp
View file

@ -1,136 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
//
// Copyright 2015 - 2016, Paul Beckingham, Federico Hernandez.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// http://www.opensource.org/licenses/mit-license.php
//
////////////////////////////////////////////////////////////////////////////////
#include <cmake.h>
#include <Timeline.h>
#include <timew.h>
#include <sstream>
////////////////////////////////////////////////////////////////////////////////
// The Timeline object represents a continuum with a defined start and end
// point. Between these two points there may be incluѕions (tracked time), and
// exclusions (untrackable time). When all known incluѕions and exclusions are
// added to a timeline, it is possible to extract (a) untracked gaps, and (b)
// blocks of tracked time. For example:
//
// Inputs:
//
// [------------------------------------------------------) Timeline
// [---------------------------------------) Inclusion
// [--------) [--------) [--------) Exclusion
//
// Derived:
//
// [-------------) [----------------) Tracked
// [-----) [-----) Gaps
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
void Timeline::include (const Interval& interval)
{
_inclusions.push_back (interval);
}
////////////////////////////////////////////////////////////////////////////////
void Timeline::exclude (const Exclusion& exclusion)
{
_exclusions.push_back (exclusion);
}
////////////////////////////////////////////////////////////////////////////////
std::vector <Interval> Timeline::tracked (Rules& rules) const
{
// Get the set of expanded exclusions that overlap the range defined by the
// timeline. If no range is defined, derive it from the set of all data.
auto exclusions = excluded (rules);
std::vector <Interval> all;
for (auto& interval : _inclusions)
{
// Closed intervals are returned as-is.
if (interval.range.ended ())
{
all.push_back (interval);
}
// Open intervals need to be split according to the exclusions.
else
{
for (auto& fragment : splitInterval (interval, exclusions))
all.push_back (fragment);
}
}
return all;
}
////////////////////////////////////////////////////////////////////////////////
// Untracked time is that which is not excluded, and not filled. Gaps.
std::vector <Range> Timeline::untracked (Rules& rules) const
{
std::vector <Range> gaps;
// Get the set of expanded exclusions that overlap the range defined by the
// timeline. If no range is defined, derive it from the set of all data.
auto exclusions = excluded (rules);
// TODO subtract all exclusions
// TODO subtract all inclusions
return gaps;
}
////////////////////////////////////////////////////////////////////////////////
// Excluded time is that which is not available for work.
std::vector <Range> Timeline::excluded (Rules& rules) const
{
// Create a range representing the whole timeline.
// If no range is defined, then assume the full range of all the inclusions.
Range overallRange {range};
if (! overallRange.started () &&
! overallRange.ended ())
overallRange = overallRangeFromIntervals (_inclusions);
// Cobmine all the non-trackable time.
return combineHolidaysAndExclusions (overallRange, rules, _exclusions);
}
////////////////////////////////////////////////////////////////////////////////
std::string Timeline::dump () const
{
std::stringstream out;
out << "Timeline range " << range.dump () << '\n';
for (auto& i : _inclusions)
out << " " << i.json ();
for (auto& e : _exclusions)
out << " " << e.dump ();
return out.str ();
}
////////////////////////////////////////////////////////////////////////////////

55
src/Timeline.h
View file

@ -1,55 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
//
// Copyright 2015 - 2016, Paul Beckingham, Federico Hernandez.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// http://www.opensource.org/licenses/mit-license.php
//
////////////////////////////////////////////////////////////////////////////////
#ifndef INCLUDED_TIMELINE
#define INCLUDED_TIMELINE
#include <Interval.h>
#include <Exclusion.h>
#include <Range.h>
#include <Rules.h>
#include <vector>
class Timeline
{
public:
Timeline () = default;
void include (const Interval&);
void exclude (const Exclusion&);
std::vector <Interval> tracked (Rules&) const;
std::vector <Range> untracked (Rules&) const;
std::vector <Range> excluded (Rules&) const;
std::string dump () const;
public:
Range range {};
private:
std::vector <Interval> _inclusions {};
std::vector <Exclusion> _exclusions {};
};
#endif

435
src/data.cpp Normal file
View file

@ -0,0 +1,435 @@
////////////////////////////////////////////////////////////////////////////////
//
// Copyright 2015 - 2016, Paul Beckingham, Federico Hernandez.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// http://www.opensource.org/licenses/mit-license.php
//
////////////////////////////////////////////////////////////////////////////////
#include <cmake.h>
#include <shared.h>
#include <Datetime.h>
#include <Duration.h>
#include <timew.h>
////////////////////////////////////////////////////////////////////////////////
// A filter is just another interval, containing start, end and tags.
//
// Supported interval forms:
// ["from"] <date> ["to"|"-" <date>]
// ["from"] <date> "for" <duration>
// <duration> ["before"|"after" <date>]
//
Interval getFilter (const CLI& cli)
{
Interval filter;
std::string start;
std::string end;
std::string duration;
std::vector <std::string> args;
for (auto& arg : cli._args)
{
if (arg.hasTag ("BINARY") ||
arg.hasTag ("CMD") ||
arg.hasTag ("EXT"))
continue;
if (arg.hasTag ("FILTER"))
{
auto canonical = arg.attribute ("canonical");
auto raw = arg.attribute ("raw");
if (arg.hasTag ("HINT"))
{
if (expandIntervalHint (canonical, start, end))
{
args.push_back ("<date>");
args.push_back ("-");
args.push_back ("<date>");
}
// Hints that are not expandable to a date range are ignored.
}
else if (arg._lextype == Lexer::Type::date)
{
if (start == "")
start = raw;
else if (end == "")
end = raw;
args.push_back ("<date>");
}
else if (arg._lextype == Lexer::Type::duration)
{
if (duration == "")
duration = raw;
args.push_back ("<duration>");
}
else if (arg.hasTag ("KEYWORD"))
{
args.push_back (raw);
}
else
{
filter.tag (raw);
}
}
}
Range range;
// <date>
if (args.size () == 1 &&
args[0] == "<date>")
{
range.start = Datetime (start);
range.end = Datetime ("now");
}
// from <date>
else if (args.size () == 2 &&
args[0] == "from" &&
args[1] == "<date>")
{
range.start = Datetime (start);
range.end = Datetime ("now");
}
// <date> to/- <date>
else if (args.size () == 3 &&
args[0] == "<date>" &&
(args[1] == "to" || args[1] == "-") &&
args[2] == "<date>")
{
range.start = Datetime (start);
range.end = Datetime (end);
}
// from/since <date> to/- <date>
else if (args.size () == 4 &&
args[0] == "from" &&
args[1] == "<date>" &&
(args[2] == "to" || args[2] == "-") &&
args[3] == "<date>")
{
range.start = Datetime (start);
range.end = Datetime (end);
}
// <date> for <duration>
else if (args.size () == 3 &&
args[0] == "<date>" &&
args[1] == "for" &&
args[2] == "<duration>")
{
range.start = Datetime (start);
range.end = Datetime (start) + Duration (duration).toTime_t ();
}
// from/since <date> for <duration>
else if (args.size () == 4 &&
(args[0] == "from" || args[0] == "since") &&
args[1] == "<date>" &&
args[2] == "for" &&
args[3] == "<duration>")
{
range.start = Datetime (start);
range.end = Datetime (start) + Duration (duration).toTime_t ();
}
// <duration> before <date>
else if (args.size () == 3 &&
args[0] == "<duration>" &&
args[1] == "before" &&
args[2] == "<date>")
{
range.start = Datetime (start) - Duration (duration).toTime_t ();
range.end = Datetime (start);
}
// <duration> after <date>
else if (args.size () == 3 &&
args[0] == "<duration>" &&
args[1] == "after" &&
args[2] == "<date>")
{
range.start = Datetime (start);
range.end = Datetime (start) + Duration (duration).toTime_t ();
}
// <duration>
else if (args.size () == 1 &&
args[0] == "<duration>")
{
range.start = Datetime ("now") - Duration (duration).toTime_t ();
range.end = Datetime ("now");
}
// Unrecognized date range construct.
else if (args.size ())
{
throw std::string ("Unrecognized date range: '") + join (" ", args) + "'.";
}
filter.range = range;
return filter;
}
////////////////////////////////////////////////////////////////////////////////
// Read rules and extract all holiday definitions. Create a Range for each
// one that spans from midnight to midnight.
std::vector <Range> getHolidays (const Rules& rules)
{
std::vector <Range> results;
for (auto& holiday : rules.all ("holidays."))
{
auto lastDot = holiday.rfind ('.');
if (lastDot != std::string::npos)
{
Range r;
Datetime d (holiday.substr (lastDot + 1), "Y_M_D");
r.start = d;
++d;
r.end = d;
results.push_back (r);
}
}
return results;
}
////////////////////////////////////////////////////////////////////////////////
// [1] Read holiday definitions from the rules, extract their dates and create
// a set of Range from them.
// [2] For 'exc day ...' exclusions, separate into daysOn and daysOff sets,
// based on whether the exclusion is additive.
// [3] Treat daysOff as additional holidays.
// [4] Subtract daysOn from the set of holidays.
// [5] Take all the 'exc <dayOfWeek> ...' exclusions and expand them into
// concrete ranges within the overall range, adding them to the results.
//
// The result is the complete set of untrackable time that lies within the
// input range. This will be a set of nights, weekends, holidays and lunchtimes.
std::vector <Range> getAllExclusions (
const Range& range,
const Rules& rules)
{
// Start with the set of all holidays, intersected with range.
std::vector <Range> results;
results = addRanges (range, results, getHolidays (rules));
auto exclusions = getExclusions (rules);
// Find exclusions 'exc day on <date>' and remove from holidays.
// Find exlcusions 'exc day off <date>' and add to holidays.
std::vector <Range> daysOn;
std::vector <Range> daysOff;
for (auto& exclusion : exclusions)
{
if (exclusion.tokens ()[1] == "day")
{
if (exclusion.additive ())
for (auto& r : exclusion.ranges (range))
daysOn.push_back (r);
else
for (auto& r : exclusion.ranges (range))
daysOff.push_back (r);
}
}
// daysOff are combined with existing holidays.
results = addRanges (range, results, daysOff);
// daysOn are subtracted from the existing holidays.
results = subtractRanges (range, results, daysOn);
// Expand all exclusions that are not 'exc day ...' into excluded ranges that
// overlage with range.
std::vector <Range> exclusionRanges;
for (auto& exclusion : exclusions)
if (exclusion.tokens ()[1] != "day")
for (auto& r : exclusion.ranges (range))
exclusionRanges.push_back (r);
return addRanges (range, results, exclusionRanges);
}
////////////////////////////////////////////////////////////////////////////////
std::vector <Exclusion> getExclusions (const Rules& rules)
{
// Add exclusions from configuration.
std::vector <Exclusion> all;
for (auto& name : rules.all ("exclusions."))
all.push_back (Exclusion (lowerCase (name), rules.get (name)));
return all;
}
////////////////////////////////////////////////////////////////////////////////
std::vector <Interval> getInclusions (Database& database)
{
std::vector <Interval> all;
for (auto& line : database.allLines ())
{
Interval i;
i.initialize (line);
all.push_back (i);
}
return all;
}
////////////////////////////////////////////////////////////////////////////////
std::vector <Interval> subset (
const Interval& filter,
const std::vector <Interval>& intervals)
{
std::vector <Interval> all;
for (auto& interval : intervals)
if (intervalMatchesFilter (interval, filter))
all.push_back (interval);
return all;
}
////////////////////////////////////////////////////////////////////////////////
std::vector <Range> subset (
const Range& range,
const std::vector <Range>& ranges)
{
std::vector <Range> all;
for (auto& r : ranges)
if (range.overlap (r))
all.push_back (r);
return all;
}
////////////////////////////////////////////////////////////////////////////////
std::vector <Interval> subset (
const Range& range,
const std::vector <Interval>& intervals)
{
std::vector <Interval> all;
for (auto& interval : intervals)
if (range.overlap (interval.range))
all.push_back (interval);
return all;
}
////////////////////////////////////////////////////////////////////////////////
std::vector <Interval> realize (
const Interval& interval,
const std::vector <Range>& exclusions)
{
std::vector <Interval> all;
// Start with a single range from the interval, from which to subtract.
std::vector <Range> pieces {interval.range};
for (auto& exclusion : exclusions)
{
std::vector <Range> split_pieces;
for (auto& piece : pieces)
for (auto& smaller_piece : piece.subtract (exclusion))
split_pieces.push_back (smaller_piece);
pieces = split_pieces;
}
// Return all the fragments as intervals.
for (auto& piece : pieces)
{
// Clone the interval, override the range.
Interval clipped {interval};
clipped.range = piece;
all.push_back (clipped);
}
return all;
}
////////////////////////////////////////////////////////////////////////////////
// Subset both ranges and additions by limits, and combine.
std::vector <Range> addRanges (
const Range& limits,
const std::vector <Range>& ranges,
const std::vector <Range>& additions)
{
std::vector <Range> results;
for (auto& range : ranges)
if (limits.overlap (range))
results.push_back (range);
for (auto& addition : additions)
if (limits.overlap (addition))
results.push_back (addition);
return results;
}
////////////////////////////////////////////////////////////////////////////////
// Subtract a set of Range from another set of Range, all within a defined
// range.
std::vector <Range> subtractRanges (
const Range& limits,
const std::vector <Range>& ranges,
const std::vector <Range>& subtractions)
{
if (! subtractions.size ())
return ranges;
std::vector <Range> results;
for (auto& r1 : ranges)
for (auto& r2 : subtractions)
for (auto& r3 : r1.subtract (r2))
results.push_back (limits.intersect (r3));
return results;
}
////////////////////////////////////////////////////////////////////////////////
// From a set of intervals, find the earliest start and the latest end, and
// return these in a Range.
Range outerRange (const std::vector <Interval>& intervals)
{
Range overall;
for (auto& interval : intervals)
{
if (interval.range.start < overall.start || overall.start.toEpoch () == 0)
overall.start = interval.range.start;
// Deliberately mixed start/end.
if (interval.range.start > overall.end)
overall.end = interval.range.start;
if (interval.range.end > overall.end)
overall.end = interval.range.end;
}
return overall;
}
////////////////////////////////////////////////////////////////////////////////