biz 0.0.1 → 1.0.0

data/lib/biz/schedule.rb

@@ -0,0 +1,37 @@
+module Biz
+  class Schedule
+
+    extend Forwardable
+
+    def initialize(&block)
+      @configuration = Configuration.new(&block)
+    end
+
+    delegate %i[
+      intervals
+      holidays
+      time_zone
+    ] => :configuration
+
+    def periods
+      Periods.new(self)
+    end
+
+    def time(scalar, unit)
+      Calculation::ForDuration.new(self, Duration.with_unit(scalar, unit))
+    end
+
+    def within(origin, terminus)
+      Calculation::DurationWithin.new(self, TimeSegment.new(origin, terminus))
+    end
+
+    def business_hours?(time)
+      Calculation::Active.new(self, time).active?
+    end
+
+    protected
+
+    attr_reader :configuration
+
+  end
+end

data/lib/biz/time.rb

@@ -0,0 +1,49 @@
+module Biz
+  class Time
+
+    MINUTE = 60
+    HOUR   = 60 * MINUTE
+    DAY    = 24 * HOUR
+    WEEK   =  7 * DAY
+
+    MINUTES_IN_HOUR = 60
+    HOURS_IN_DAY    = 24
+    DAYS_IN_WEEK    = 7
+
+    MINUTES_IN_DAY  = MINUTES_IN_HOUR * HOURS_IN_DAY
+    MINUTES_IN_WEEK = MINUTES_IN_DAY * DAYS_IN_WEEK
+
+    BIG_BANG   = ::Time.new(-10**100)
+    HEAT_DEATH = ::Time.new(10**100)
+
+    attr_reader :time_zone
+
+    def initialize(time_zone)
+      @time_zone = time_zone
+    end
+
+    def local(time)
+      time_zone.utc_to_local(time.utc)
+    end
+
+    def on_date(date, day_time)
+      time_zone.local_to_utc(
+        ::Time.utc(
+          date.year,
+          date.month,
+          date.mday,
+          day_time.hour,
+          day_time.minute
+        ),
+        true
+      )
+    rescue TZInfo::PeriodNotFound
+      on_date(date, DayTime.new(day_time.day_minute + MINUTES_IN_HOUR))
+    end
+
+    def during_week(week, week_time)
+      on_date(week.start_date + week_time.wday, week_time)
+    end
+
+  end
+end

data/lib/biz/time_segment.rb

@@ -0,0 +1,63 @@
+module Biz
+  class TimeSegment
+
+    include Equalizer.new(:start_time, :end_time)
+
+    def self.before(time)
+      new(Time::BIG_BANG, time)
+    end
+
+    def self.after(time)
+      new(time, Time::HEAT_DEATH)
+    end
+
+    attr_reader :start_time,
+                :end_time
+
+    def initialize(start_time, end_time)
+      @start_time = start_time
+      @end_time   = end_time
+    end
+
+    def duration
+      Duration.new(end_time - start_time)
+    end
+
+    def endpoints
+      [start_time, end_time]
+    end
+
+    def empty?
+      start_time >= end_time
+    end
+
+    def contains?(time)
+      (start_time..end_time).cover?(time)
+    end
+
+    def &(other)
+      self.class.new(
+        lower_bound(other),
+        [lower_bound(other), upper_bound(other)].max
+      )
+    end
+
+    def /(other)
+      [
+        self.class.new(start_time, other.start_time),
+        self.class.new(other.end_time, end_time)
+      ].reject(&:empty?).map { |potential| self & potential }
+    end
+
+    private
+
+    def lower_bound(other)
+      [self, other].map(&:start_time).max
+    end
+
+    def upper_bound(other)
+      [self, other].map(&:end_time).min
+    end
+
+  end
+end

data/lib/biz/timeline.rb

@@ -0,0 +1,24 @@
+module Biz
+  class Timeline
+
+    attr_reader :periods
+
+    def initialize(periods)
+      @periods = periods
+    end
+
+    def forward
+      Forward.new(periods)
+    end
+
+    def backward
+      Backward.new(periods)
+    end
+
+  end
+end
+
+require 'biz/timeline/abstract'
+
+require 'biz/timeline/forward'
+require 'biz/timeline/backward'

data/lib/biz/timeline/abstract.rb

@@ -0,0 +1,41 @@
+module Biz
+  class Timeline
+    class Abstract
+
+      attr_reader :periods
+
+      def initialize(periods)
+        @periods = periods.lazy
+      end
+
+      def until(terminus)
+        return enum_for(:until, terminus) unless block_given?
+
+        periods.map { |period|
+          period & comparison_period(period, terminus)
+        }.each do |period|
+          yield period unless period.empty?
+
+          break if occurred?(period, terminus)
+        end
+      end
+
+      def for(duration)
+        return enum_for(:for, duration) unless block_given?
+
+        remaining = duration
+
+        periods.map { |period|
+          period & duration_period(period, remaining)
+        }.each do |period|
+          yield period unless period.empty?
+
+          remaining -= period.duration
+
+          break unless remaining.positive?
+        end
+      end
+
+    end
+  end
+end

data/lib/biz/timeline/backward.rb

@@ -0,0 +1,24 @@
+module Biz
+  class Timeline
+    class Backward < Abstract
+
+      private
+
+      def occurred?(period, time)
+        period.start_time <= time
+      end
+
+      def comparison_period(period, terminus)
+        TimeSegment.new(terminus, period.end_time)
+      end
+
+      def duration_period(period, duration)
+        TimeSegment.new(
+          period.end_time - duration.in_seconds,
+          period.end_time
+        )
+      end
+
+    end
+  end
+end

data/lib/biz/timeline/forward.rb

@@ -0,0 +1,24 @@
+module Biz
+  class Timeline
+    class Forward < Abstract
+
+      private
+
+      def occurred?(period, time)
+        period.end_time >= time
+      end
+
+      def comparison_period(period, terminus)
+        TimeSegment.new(period.start_time, terminus)
+      end
+
+      def duration_period(period, duration)
+        TimeSegment.new(
+          period.start_time,
+          period.start_time + duration.in_seconds
+        )
+      end
+
+    end
+  end
+end

data/lib/biz/version.rb

@@ -1,3 +1,5 @@
 module Biz
-  VERSION = "0.0.1"
+
+  VERSION = '1.0.0'
+
 end

data/lib/biz/week.rb

@@ -0,0 +1,67 @@
+module Biz
+  class Week
+
+    include Comparable
+
+    extend Forwardable
+
+    def self.from_date(date)
+      new(Day.from_date(date).to_i / Time::DAYS_IN_WEEK)
+    end
+
+    def self.from_time(time)
+      from_date(time.to_date)
+    end
+
+    class << self
+
+      alias_method :since_epoch, :from_time
+
+    end
+
+    attr_reader :week
+
+    delegate %i[
+      to_s
+      to_i
+      to_int
+    ] => :week
+
+    def initialize(week)
+      @week = Integer(week)
+    end
+
+    def start_date
+      Date.from_day(week * Time::DAYS_IN_WEEK)
+    end
+
+    def succ
+      self.class.new(week.succ)
+    end
+
+    def downto(final_week)
+      return enum_for(:downto, final_week) unless block_given?
+
+      week.downto(final_week.to_i).each do |raw_week|
+        yield self.class.new(raw_week)
+      end
+    end
+
+    def +(other)
+      self.class.new(week + other.week)
+    end
+
+    def coerce(other)
+      [self.class.new(other), self]
+    end
+
+    protected
+
+    def <=>(other)
+      return nil unless other.respond_to?(:to_i)
+
+      week <=> other.to_i
+    end
+
+  end
+end

data/lib/biz/week_time.rb

@@ -0,0 +1,26 @@
+module Biz
+  module WeekTime
+    class << self
+
+      def from_time(time)
+        Start.from_time(time)
+      end
+
+      def start(week_minute)
+        Start.new(week_minute)
+      end
+
+      def end(week_minute)
+        End.new(week_minute)
+      end
+
+      alias_method :build, :start
+
+    end
+  end
+end
+
+require 'biz/week_time/abstract'
+
+require 'biz/week_time/end'
+require 'biz/week_time/start'

data/lib/biz/week_time/abstract.rb

@@ -0,0 +1,75 @@
+module Biz
+  module WeekTime
+    class Abstract
+
+      include AbstractType
+      include Comparable
+      include Memoizable
+
+      extend Forwardable
+
+      def self.from_time(time)
+        new(
+          time.wday * Time::MINUTES_IN_DAY +
+            time.hour * Time::MINUTES_IN_HOUR +
+            time.min
+        )
+      end
+
+      attr_reader :week_minute
+
+      def initialize(week_minute)
+        @week_minute = Integer(week_minute)
+      end
+
+      def wday_symbol
+        day_of_week.symbol
+      end
+
+      def coerce(other)
+        [self.class.new(other), self]
+      end
+
+      delegate wday: :day_of_week
+
+      delegate %i[
+        hour
+        minute
+        day_minute
+        timestamp
+      ] => :day_time
+
+      delegate strftime: :week_time
+
+      delegate %i[
+        to_s
+        to_i
+        to_int
+      ] => :week_minute
+
+      protected
+
+      def <=>(other)
+        return nil unless other.respond_to?(:to_i)
+
+        week_minute <=> other.to_i
+      end
+
+      private
+
+      def week_time
+        ::Time.new(
+          Date::EPOCH.year,
+          Date::EPOCH.month,
+          Date::EPOCH.mday + wday,
+          hour,
+          minute
+        )
+      end
+
+      abstract_method :day_of_week,
+                      :day_time
+
+    end
+  end
+end