gb_work_day 0.0.1

data/lib/gb_work_day/helpers/date.rb

@@ -0,0 +1,33 @@
+require 'gb_work_day/interval'
+module GBWorkDay
+  class Date < ::Date
+    attr_accessor :work_week
+
+    def -(other)
+      if other.is_a?(::Date) || other.is_a?(::Time)
+        Interval.new(self, other, week: self.work_week).work_days
+      else
+        super
+      end
+    end
+
+    private
+
+    # @return [GBWorkDay::WorkWeek]
+    def default_week
+      self.work_week || GBWorkDay::WorkWeek.current
+    end
+
+    class << self
+      # Create {GBWorkingDay::Date} object from a given Date object.
+      # Copy constructor.
+      #
+      # @param date [Date]
+      def from_date(date, work_week = nil)
+        new_date = self.jd(date.jd)
+        new_date.work_week = work_week if work_week
+        new_date
+      end
+    end
+  end
+end

data/lib/gb_work_day/helpers/time.rb

@@ -0,0 +1,33 @@
+require 'gb_work_day/interval'
+module GBWorkDay
+  class Time < ::Time
+    attr_accessor :work_week
+
+    def -(other)
+      if other.is_a?(::Time) || other.is_a?(::Date)
+        Interval.new(self, other, week: work_week).work_days
+      else
+        super
+      end
+    end
+
+    private
+
+    # @return [GBWorkDay::WorkWeek]
+    def default_week
+      self.work_week || GBWorkDay::WorkWeek.current
+    end
+
+    class << self
+      # Create {GBWorkingDay::Time} object from a given Time object.
+      # Copy constructor.
+      #
+      # @param time [Time]
+      def from_time(time, work_week=nil)
+        new_time = self.at(time)
+        new_time.work_week = work_week if work_week
+        new_time
+      end
+    end
+  end
+end

data/lib/gb_work_day/interval.rb

@@ -0,0 +1,55 @@
+require 'gb_work_day/work_week'
+require 'gb_work_day/duration'
+module GBWorkDay
+  class Interval
+    attr_reader :start_time, :end_time
+
+    # @param start_time [Time, Date]
+    # @param end_time [Time, Date]
+    # @param params [Hash]
+    # @option params [Fixnum] :work_days number of work days in a week, default is 7
+    # @option params [Fixnum] :week_start first working day in a week as number. Default value is 1 corresponding to Monday.
+    def initialize(start_time, end_time, params=Hash.new)
+      @start_time = start_time
+      @end_time = end_time
+      @symbol = 1
+      revert if @start_time > @end_time
+      @working_week = params[:week]
+      unless @working_week
+        if params[:work_days] || params[:week_start]
+          work_days = params.fetch(:work_days, 7)
+          week_start = params.fetch(:week_start, 1)
+          @working_week = WorkWeek.new work_days, week_start
+        else
+          @working_week = WorkWeek.current
+        end
+      end
+    end
+
+    # @return [Integer] Number of working days in a given period
+    def work_days
+      date = @start_time
+      work_days = 0
+      while date < end_time
+        work_days += 1 if @working_week.work_day?(date)
+        date += 1.day
+      end
+      Duration.new(work_days * @symbol, @working_week)
+    end
+
+    alias_method :duration, :work_days
+
+    def endpoints
+      [start_time, end_time]
+    end
+
+    private
+
+    def revert
+      new_end_time = @start_time
+      @start_time = @end_time
+      @end_time = new_end_time
+      @symbol= @symbol * -1
+    end
+  end
+end

data/lib/gb_work_day/version.rb

@@ -0,0 +1,3 @@
+module GBWorkDay
+  VERSION = '0.0.1'
+end

data/lib/gb_work_day/work_week.rb

@@ -0,0 +1,58 @@
+module GBWorkDay
+  class WorkWeek
+    attr_reader :work_days_per_week, :free_days_per_week, :work_days, :free_days, :week_start
+
+    # @param work_days [#to_i] Amount of working days in a week. Default value is 7.
+    # @param week_start [#to_i] Number of a week day, when work starts. Default value is 1 corresponding to Monday
+    def initialize(work_days=7, week_start=1)
+      work_days = work_days.to_i
+      week_start = week_start.to_i
+      raise ArgumentError, 'Work days have to be between 0 and 7!' unless work_days >= 0 && work_days <= 7
+      @work_days_per_week = work_days
+      @week_start = week_start % 7
+      @free_days_per_week = 7 - @work_days_per_week
+      @work_days = []
+      @work_days_per_week.times do
+        day = week_start % 7
+        @work_days << (day != 0 ? day : 7)
+        week_start += 1
+      end
+      @work_days.sort!
+      @free_days = (1..7).to_a - @work_days
+    end
+
+    # Check if given day is a work day
+    # @param day [Time, Date]
+    def work_day?(day)
+      week_day = day.wday
+      week_day = 7 if week_day == 0
+      work_days.include? week_day
+    end
+
+    # Check if given day is a work day
+    # @param day [Time, Date]
+    def free_day?(day)
+      week_day = day.wday
+      week_day = 7 if week_day == 0
+      free_days.include? week_day
+    end
+
+    def ==(other) # :nodoc:
+      work_days_per_week == other.work_days_per_week && week_start == other.week_start
+    end
+
+    def eql?(other) # :nodoc:
+      work_days_per_week.eql?(other.work_days_per_week) && week_start.eql?(other.week_start)
+    end
+
+    class << self
+      def current
+        Thread.current[:working_week] ||= self.new
+      end
+
+      def current=(new_week)
+        Thread.current[:working_week] = new_week if WorkWeek === new_week
+      end
+    end
+  end
+end

data/spec/core_ext/date_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'gb_work_day/core_ext/date'
+require 'gb_work_day/core_ext/integer'
+require 'active_support/time'
+
+describe 'Date extensions' do
+  before(:all) { GBWorkDay::WorkWeek.current = GBWorkDay::WorkWeek.new(5) }
+  after(:all)  { GBWorkDay::WorkWeek.current = GBWorkDay::WorkWeek.new() }
+
+  it 'should respond to work?' do
+    expect(Date.today.beginning_of_week.work?).to be_truthy
+    expect(Date.today.end_of_week.work?).to be_falsey
+  end
+
+  it 'should respond to free?' do
+    expect(Date.today.beginning_of_week.free?).to be_falsey
+    expect(Date.today.end_of_week.free?).to be_truthy
+  end
+
+  it 'should respond to work_date' do
+    date = Date.today
+    expect(date.work_date).to be_kind_of GBWorkDay::Date
+    expect(date.work_date).to eq date
+  end
+
+  it 'should respond to to_work_date' do
+    date = Date.today
+    expect(date.to_work_date).to be_kind_of GBWorkDay::Date
+    expect(date.to_work_date).to eq date
+  end
+
+  it 'should respond to to_work' do
+    date = Date.today
+    expect(date.to_work).to be_kind_of GBWorkDay::Date
+    expect(date.to_work).to eq date
+  end
+
+  it 'should properly subtract work dates' do
+    expect(Date.today - Date.tomorrow.to_work_date).to be_a_kind_of GBWorkDay::Duration
+  end
+
+  it 'should return next_work_day' do
+    monday = Date.today.beginning_of_week
+    friday = monday + 4.days
+    sunday = Date.today.end_of_week
+    expect(monday.next_work_day). to eq (monday + 1.day)
+    expect(friday.next_work_day). to eq (friday + 3.day)
+    expect(sunday.next_work_day). to eq (sunday + 1.day)
+  end
+
+  it 'should properly subtract work duration' do
+    monday = Date.today.beginning_of_week
+    wednesday = monday + 2.days
+    expect(monday - 1.work_day).to eq (monday - 3.days)
+    expect(wednesday - 2.work_day).to eq (wednesday - 2.days)
+  end
+
+  it 'should properly add work duration' do
+    monday = Date.today.beginning_of_week
+    wednesday = monday + 2.days
+    friday = monday + 4.days
+    expect(monday + 1.work_day).to eq (monday + 1.days)
+    expect(friday + 1.work_day).to eq (friday + 3.days)
+    expect(wednesday + 2.work_day).to eq (wednesday + 2.days)
+  end
+end

data/spec/core_ext/integer_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'gb_work_day/core_ext/integer'
+require 'gb_work_day/duration'
+
+describe 'Integer extensions' do
+
+  it 'should respond work_days' do
+    expect(2.work_days).to be_kind_of GBWorkDay::Duration
+    expect(2.work_days.work_days).to eq 2
+    expect(2.work_days.week).to eq GBWorkDay::WorkWeek.current
+  end
+
+  it 'should respond work_day' do
+    expect(1.work_day).to be_kind_of GBWorkDay::Duration
+    expect(1.work_day.work_days).to eq 1
+    expect(1.work_day.week).to eq GBWorkDay::WorkWeek.current
+  end
+
+  it 'should setup proper week on work_days' do
+    week = GBWorkDay::WorkWeek.new(5, 1)
+    expect(2.work_days(week).week).to eq week
+  end
+
+  it 'should be able to sum' do
+    expect(1.work_day + 2).to eq 3.work_days
+    expect(1.work_day + 2.work_day).to eq 3.work_days
+  end
+end

data/spec/core_ext/time_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'gb_work_day/core_ext/time'
+require 'gb_work_day/core_ext/integer'
+require 'active_support/time'
+
+describe 'Time extensions' do
+  before(:all) { GBWorkDay::WorkWeek.current = GBWorkDay::WorkWeek.new(5) }
+  after(:all)  { GBWorkDay::WorkWeek.current = GBWorkDay::WorkWeek.new() }
+
+  it 'should respond to work?' do
+    expect(Time.now.beginning_of_week.work?).to be_truthy
+    expect(Time.now.end_of_week.work?).to be_falsey
+  end
+
+  it 'should respond to free?' do
+    expect(Time.now.beginning_of_week.free?).to be_falsey
+    expect(Time.now.end_of_week.free?).to be_truthy
+  end
+
+  it 'should respond to work_time' do
+    time = Time.now
+    expect(time.work_time).to be_kind_of GBWorkDay::Time
+    expect(time.work_time).to eq time
+  end
+
+  it 'should respond to to_work_time' do
+    time = Time.now
+    expect(time.to_work_time).to be_kind_of GBWorkDay::Time
+    expect(time.to_work_time).to eq time
+  end
+
+  it 'should respond to to_work' do
+    time = Time.now
+    expect(time.to_work).to be_kind_of GBWorkDay::Time
+    expect(time.to_work).to eq time
+  end
+
+  it 'should properly subtract work times' do
+    expect(Time.now - (Time.now + 1.day).to_work_time).to be_a_kind_of GBWorkDay::Duration
+  end
+
+  it 'should return next_work_day' do
+    monday = Time.now.beginning_of_week
+    friday = monday + 4.days
+    sunday = Time.now.end_of_week
+    expect(monday.next_work_day). to eq (monday + 1.day)
+    expect(friday.next_work_day). to eq (friday + 3.day)
+    expect(sunday.next_work_day). to eq (sunday + 1.day)
+  end
+
+  it 'should properly subtract work duration' do
+    monday = Time.now.beginning_of_week
+    wednesday = monday + 2.days
+    expect(monday - 1.work_day).to eq (monday - 3.days)
+    expect(wednesday - 2.work_day).to eq (wednesday - 2.days)
+  end
+
+  it 'should properly add work duration' do
+    monday = Time.now.beginning_of_week
+    wednesday = monday + 2.days
+    friday = monday + 4.days
+    expect(monday + 1.work_day).to eq (monday + 1.days)
+    expect(friday + 1.work_day).to eq (friday + 3.days)
+    expect(wednesday + 2.work_day).to eq (wednesday + 2.days)
+  end
+end

data/spec/duration_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+require 'gb_work_day/duration'
+require 'active_support/time'
+
+describe GBWorkDay::Duration do
+
+  it 'should add durations' do
+    expect(GBWorkDay::Duration.new(1) + GBWorkDay::Duration.new(1)).to eq GBWorkDay::Duration.new(2)
+    expect(GBWorkDay::Duration.new(1) + 1).to eq GBWorkDay::Duration.new(2)
+  end
+
+  it 'should subtract durations' do
+    expect(GBWorkDay::Duration.new(10) - GBWorkDay::Duration.new(7)).to eq GBWorkDay::Duration.new(3)
+    expect(GBWorkDay::Duration.new(10) - 3).to eq GBWorkDay::Duration.new(7)
+  end
+
+  it 'should negate durations' do
+    expect(-GBWorkDay::Duration.new(7)).to eq GBWorkDay::Duration.new(-7)
+  end
+
+  it 'should respond to is_a?' do
+    expect(GBWorkDay::Duration.new(1).is_a? GBWorkDay::Duration).to be_truthy
+    expect(GBWorkDay::Duration.new(1).is_a? Numeric).to be_truthy
+  end
+
+  it 'should respond to instance_of?' do
+    expect(GBWorkDay::Duration.new(1).instance_of? GBWorkDay::Duration).to be_truthy
+    expect(GBWorkDay::Duration.new(1).instance_of? Fixnum).to be_truthy
+  end
+
+  it 'should respond do equality signs' do
+    expect(GBWorkDay::Duration.new(1) == GBWorkDay::Duration.new(1)).to be_truthy
+    expect(GBWorkDay::Duration.new(1) == GBWorkDay::Duration.new(2)).to be_falsey
+    expect(GBWorkDay::Duration.new(1) == 1).to be_truthy
+    expect(GBWorkDay::Duration.new(1) == 2).to be_falsey
+
+    week = GBWorkDay::WorkWeek.new(3, 3)
+    expect(GBWorkDay::Duration.new(1, week) == GBWorkDay::Duration.new(1)).to be_falsey
+    expect(GBWorkDay::Duration.new(1, week) == GBWorkDay::Duration.new(2)).to be_falsey
+
+    expect(GBWorkDay::Duration.new(1).eql? GBWorkDay::Duration.new(1)).to be_truthy
+    expect(GBWorkDay::Duration.new(1).eql? GBWorkDay::Duration.new(2)).to be_falsey
+  end
+
+  it 'should return number of sec for to_s' do
+    expect(GBWorkDay::Duration.new(1).to_s).to eq '86400'
+  end
+
+
+  it 'should respond to_i' do
+    expect(GBWorkDay::Duration.new(1).to_i).to eq 86400
+    expect(GBWorkDay::Duration.new(1).to_i(:days)).to eq 1
+  end
+
+  it 'should respond to inspect' do
+    expect(GBWorkDay::Duration.new(1).inspect).to be_kind_of String
+  end
+
+  it 'should calculate proper time for future' do
+    week = GBWorkDay::WorkWeek.new(5, 1)
+    monday = Time.now.beginning_of_week
+
+    expect(GBWorkDay::Duration.new(1, week).since(monday)).to eq monday + 1.day
+    expect(GBWorkDay::Duration.new(-1, week).since(monday)).to eq monday - 3.days
+    expect(GBWorkDay::Duration.new(3, week).since(monday)).to eq monday + 3.days
+    expect(GBWorkDay::Duration.new(5, week).since(monday)).to eq monday + 7.days
+    expect(GBWorkDay::Duration.new(6, week).since(monday)).to eq monday + 8.days
+    expect(GBWorkDay::Duration.new(16, week).since(monday)).to eq monday + 22.days
+  end
+
+  it 'should calculate proper date for future' do
+    week = GBWorkDay::WorkWeek.new(5, 1)
+    monday = Date.today.beginning_of_week
+
+    expect(GBWorkDay::Duration.new(1, week).since(monday)).to eq monday + 1.day
+    expect(GBWorkDay::Duration.new(-1, week).since(monday)).to eq monday - 3.days
+    expect(GBWorkDay::Duration.new(3, week).since(monday)).to eq monday + 3.days
+    expect(GBWorkDay::Duration.new(5, week).since(monday)).to eq monday + 7.days
+    expect(GBWorkDay::Duration.new(6, week).since(monday)).to eq monday + 8.days
+    expect(GBWorkDay::Duration.new(16, week).since(monday)).to eq monday + 22.days
+  end
+
+  it 'should calculate proper time for past' do
+    week = GBWorkDay::WorkWeek.new(5, 1)
+    monday = Time.now.beginning_of_week
+
+    expect(GBWorkDay::Duration.new(1, week).until(monday)).to eq monday - 3.days
+    expect(GBWorkDay::Duration.new(-1, week).until(monday)).to eq monday + 1.days
+    expect(GBWorkDay::Duration.new(3, week).until(monday)).to eq monday - 5.days
+    expect(GBWorkDay::Duration.new(6, week).until(monday)).to eq monday - 10.days
+    expect(GBWorkDay::Duration.new(16, week).until(monday)).to eq monday - 24.days
+  end
+
+  it 'should calculate proper date for past' do
+    week = GBWorkDay::WorkWeek.new(5, 1)
+    monday = Date.today.beginning_of_week
+
+    expect(GBWorkDay::Duration.new(1, week).until(monday)).to eq monday - 3.days
+    expect(GBWorkDay::Duration.new(-1, week).until(monday)).to eq monday + 1.days
+    expect(GBWorkDay::Duration.new(3, week).until(monday)).to eq monday - 5.days
+    expect(GBWorkDay::Duration.new(6, week).until(monday)).to eq monday - 10.days
+    expect(GBWorkDay::Duration.new(16, week).until(monday)).to eq monday - 24.days
+  end
+end