biz 0.0.1 → 1.0.0

data/lib/biz/day_of_week.rb

@@ -0,0 +1,81 @@
+module Biz
+  class DayOfWeek
+
+    SYMBOLS = [:sun, :mon, :tue, :wed, :thu, :fri, :sat]
+
+    def self.from_time(time)
+      DAYS.fetch(time.wday)
+    end
+
+    def self.from_symbol(symbol)
+      DAYS.fetch(SYMBOLS.index(symbol))
+    end
+
+    def self.first
+      DAYS.first
+    end
+
+    def self.last
+      DAYS.last
+    end
+
+    class << self
+
+      alias_method :from_date, :from_time
+
+    end
+
+    attr_reader :wday
+
+    def initialize(wday)
+      @wday = Integer(wday)
+    end
+
+    def contains?(week_time)
+      minutes.cover?(week_time)
+    end
+
+    def start_minute
+      wday * Time::MINUTES_IN_DAY
+    end
+
+    def end_minute
+      start_minute + Time::MINUTES_IN_DAY
+    end
+
+    def minutes
+      start_minute..end_minute
+    end
+
+    def week_minute(day_minute)
+      start_minute + day_minute
+    end
+
+    def day_minute(week_minute)
+      (week_minute - 1) % Time::MINUTES_IN_DAY + 1
+    end
+
+    def symbol
+      SYMBOLS.fetch(wday)
+    end
+
+    DAYS = [
+      SUNDAY    = new(0),
+      MONDAY    = new(1),
+      TUESDAY   = new(2),
+      WEDNESDAY = new(3),
+      THURSDAY  = new(4),
+      FRIDAY    = new(5),
+      SATURDAY  = new(6)
+    ]
+
+    WEEKDAYS = [
+      MONDAY,
+      TUESDAY,
+      WEDNESDAY,
+      THURSDAY,
+      FRIDAY
+    ]
+
+  end
+end

data/lib/biz/day_time.rb

@@ -0,0 +1,95 @@
+module Biz
+  class DayTime
+
+    TIMESTAMP_FORMAT  = '%02d:%02d'
+    TIMESTAMP_PATTERN = /(?<hour>\d{2}):(?<minute>\d{2})/
+
+    include Comparable
+
+    extend Forwardable
+
+    def self.from_hour(hour)
+      new(hour * Time::MINUTES_IN_HOUR)
+    end
+
+    def self.from_timestamp(timestamp)
+      timestamp.match(TIMESTAMP_PATTERN) { |match|
+        new(match[:hour].to_i * Time::MINUTES_IN_HOUR + match[:minute].to_i)
+      }
+    end
+
+    def self.midnight
+      MIDNIGHT
+    end
+
+    def self.noon
+      NOON
+    end
+
+    def self.endnight
+      ENDNIGHT
+    end
+
+    class << self
+
+      alias_method :am, :midnight
+
+      alias_method :pm, :noon
+
+    end
+
+    attr_reader :day_minute
+
+    delegate strftime: :day_time
+
+    delegate %i[
+      to_i
+      to_int
+    ] => :day_minute
+
+    def initialize(day_minute)
+      @day_minute = Integer(day_minute)
+    end
+
+    def hour
+      day_minute / Time::MINUTES_IN_HOUR
+    end
+
+    def minute
+      day_minute % Time::MINUTES_IN_HOUR
+    end
+
+    def timestamp
+      format(TIMESTAMP_FORMAT, hour, minute)
+    end
+
+    def coerce(other)
+      [self.class.new(other), self]
+    end
+
+    protected
+
+    def <=>(other)
+      return nil unless other.respond_to?(:to_i)
+
+      day_minute <=> other.to_i
+    end
+
+    private
+
+    def day_time
+      ::Time.new(
+        Date::EPOCH.year,
+        Date::EPOCH.month,
+        Date::EPOCH.mday,
+        hour,
+        minute
+      )
+    end
+
+    MIDNIGHT = from_hour(0)
+    NOON     = from_hour(12)
+    ENDNIGHT = from_hour(24)
+
+  end
+end

data/lib/biz/duration.rb

@@ -0,0 +1,100 @@
+module Biz
+  class Duration
+
+    UNITS = Set.new(%i[second seconds minute minutes hour hours day days])
+
+    include Equalizer.new(:seconds)
+    include Comparable
+
+    extend Forwardable
+
+    class << self
+
+      def with_unit(scalar, unit)
+        unless UNITS.include?(unit)
+          fail ArgumentError, 'The unit is not supported.'
+        end
+
+        public_send(unit, scalar)
+      end
+
+      def seconds(seconds)
+        new(seconds)
+      end
+
+      alias_method :second, :seconds
+
+      def minutes(minutes)
+        new(minutes * Time::MINUTE)
+      end
+
+      alias_method :minute, :minutes
+
+      def hours(hours)
+        new(hours * Time::HOUR)
+      end
+
+      alias_method :hour, :hours
+
+      def days(days)
+        new(days * Time::DAY)
+      end
+
+      alias_method :day, :days
+
+    end
+
+    attr_reader :seconds
+
+    delegate to_i: :seconds
+
+    def initialize(seconds)
+      @seconds = Integer(seconds)
+    end
+
+    def in_seconds
+      seconds
+    end
+
+    def in_minutes
+      seconds / Time::MINUTE
+    end
+
+    def in_hours
+      seconds / Time::HOUR
+    end
+
+    def in_days
+      seconds / Time::DAY
+    end
+
+    def +(other)
+      self.class.new(seconds + other.seconds)
+    end
+
+    def -(other)
+      self.class.new(seconds - other.seconds)
+    end
+
+    def positive?
+      seconds > 0
+    end
+
+    def abs
+      self.class.new(seconds.abs)
+    end
+
+    def coerce(other)
+      [self.class.new(other), self]
+    end
+
+    protected
+
+    def <=>(other)
+      return nil unless other.respond_to?(:to_i)
+
+      seconds <=> other.to_i
+    end
+
+  end
+end

data/lib/biz/holiday.rb

@@ -0,0 +1,26 @@
+module Biz
+  class Holiday
+
+    include Equalizer.new(:date, :time_zone)
+
+    attr_reader :date,
+                :time_zone
+
+    def initialize(date, time_zone)
+      @date      = date
+      @time_zone = time_zone
+    end
+
+    def contains?(time)
+      date == Time.new(time_zone).local(time).to_date
+    end
+
+    def to_time_segment
+      TimeSegment.new(
+        Time.new(time_zone).on_date(date, DayTime.midnight),
+        Time.new(time_zone).on_date(date, DayTime.endnight)
+      )
+    end
+
+  end
+end

data/lib/biz/interval.rb

@@ -0,0 +1,35 @@
+module Biz
+  class Interval
+
+    include Equalizer.new(:start_time, :end_time, :time_zone)
+
+    attr_reader :start_time,
+                :end_time,
+                :time_zone
+
+    def initialize(start_time, end_time, time_zone)
+      @start_time = start_time
+      @end_time   = end_time
+      @time_zone  = time_zone
+    end
+
+    def endpoints
+      [start_time, end_time]
+    end
+
+    def contains?(time)
+      (start_time...end_time).cover?(
+        WeekTime.from_time(Time.new(time_zone).local(time))
+      )
+    end
+
+    def to_time_segment(week)
+      TimeSegment.new(
+        *endpoints.map { |endpoint|
+          Time.new(time_zone).during_week(week, endpoint)
+        }
+      )
+    end
+
+  end
+end

data/lib/biz/periods.rb

@@ -0,0 +1,24 @@
+module Biz
+  class Periods
+
+    attr_reader :schedule
+
+    def initialize(schedule)
+      @schedule = schedule
+    end
+
+    def after(origin)
+      After.new(schedule, origin)
+    end
+
+    def before(origin)
+      Before.new(schedule, origin)
+    end
+
+  end
+end
+
+require 'biz/periods/abstract'
+
+require 'biz/periods/after'
+require 'biz/periods/before'

data/lib/biz/periods/abstract.rb

@@ -0,0 +1,49 @@
+module Biz
+  class Periods
+    class Abstract < Enumerator::Lazy
+
+      extend Forwardable
+
+      attr_reader :schedule,
+                  :origin
+
+      def initialize(schedule, origin)
+        @schedule = schedule
+        @origin   = origin
+
+        super(periods) do |yielder, period| yielder << period end
+      end
+
+      delegate time_zone: :schedule
+
+      def timeline
+        Timeline.new(self)
+      end
+
+      private
+
+      def periods
+        weeks.lazy.flat_map { |week|
+          business_periods(week)
+        }.select { |business_period|
+          relevant?(business_period)
+        }.map { |business_period|
+          business_period & boundary
+        }.reject { |business_period|
+          schedule.holidays.any? { |holiday|
+            holiday.contains?(business_period.start_time)
+          }
+        }
+      end
+
+      def business_periods(week)
+        intervals.lazy.map { |interval| interval.to_time_segment(week) }
+      end
+
+      def intervals
+        schedule.intervals
+      end
+
+    end
+  end
+end

data/lib/biz/periods/after.rb

@@ -0,0 +1,24 @@
+module Biz
+  class Periods
+    class After < Abstract
+
+      private
+
+      def weeks
+        Range.new(
+          Week.since_epoch(Time.new(time_zone).local(origin)),
+          Week.since_epoch(Time::HEAT_DEATH)
+        )
+      end
+
+      def relevant?(period)
+        origin < period.end_time
+      end
+
+      def boundary
+        TimeSegment.after(origin)
+      end
+
+    end
+  end
+end

data/lib/biz/periods/before.rb

@@ -0,0 +1,27 @@
+module Biz
+  class Periods
+    class Before < Abstract
+
+      private
+
+      def weeks
+        Week.since_epoch(Time.new(time_zone).local(origin)).downto(
+          Week.since_epoch(Time::BIG_BANG)
+        )
+      end
+
+      def relevant?(period)
+        origin > period.start_time
+      end
+
+      def boundary
+        TimeSegment.before(origin)
+      end
+
+      def intervals
+        super.reverse
+      end
+
+    end
+  end
+end