availabiliter 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4398863d21393841d616f4fd47c7cfd3d5c7c3c04839735e4508cae695f07f1
-  data.tar.gz: dc7736e7c8a5ee4498719a8976e73b5923b35b0f32154bac151009db6eeb98b7
+  metadata.gz: acbff7e9ed2d5615c2298a6b8802fe20920b594a19292fdff70d933100610a4d
+  data.tar.gz: 71b01103cb94ebfd73733135d95758bbc4fbd0c4936d2199f7917d3f9be06904
 SHA512:
-  metadata.gz: 60eb5709da8cd9dedee6e7246c517f27117e23aa04cfeb69e8945e67acdaada2e5b86e1b0c5ba67a94dcd2e88b06841b8881b5a9bd179e8d76f090cb09c66240
-  data.tar.gz: cf00b270e3afbef8253100d3784ce435ada6f2ef69a00ba6af41e01e26a6473295f339dc6f9ceaaa1f21ec9136c806c1d7bccb8c06e54bc6233b9773d40a89d5
+  metadata.gz: b5658fb8a5aae7db823d0767b6eff6ecd65fc305258e2e79ec483df63d8bed008fdca0a54ec1ccdb1a0079fabdc1887262f130401e77a716f297d959ef5fbe64
+  data.tar.gz: 5c0bf3d49fd0064b597cbfd5d83eccbebe6bfebf2a78c265904bb9e9ea044d00fb027e6588e38337bf61c6884faa41340851185089b426c3d3897cddcecae0a4

data/.gitignore

@@ -12,4 +12,10 @@
 .rspec_status
 
 # byebug historic
-.byebug_history
+.byebug_history
+
+#irb history
+.irb_history
+
+# rbenv local setting
+.ruby-version

data/.rubocop.yml

@@ -1,5 +1,6 @@
 AllCops:
   TargetRubyVersion: 2.7.2
+  NewCops: enable
 
 Style/StringLiterals:
   Enabled: true
@@ -11,7 +12,13 @@ Style/StringLiteralsInInterpolation:
 
 Layout/LineLength:
   Max: 120
+  Exclude:
+    - 'spec/**/*'
+    - 'rakelib/*'
 
 Metrics/BlockLength:
   Exclude:
-    - 'spec/**/*'
+    - 'spec/**/*'
+
+Style/FrozenStringLiteralComment:
+  Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## Future releases
-- DateTime calculation
+- Easy integration in Rails
+- Allow to pick your own infinity format
+
+## 1.0.0
+
+- Adds support for Time and Unix timestamps
+- Allows to pick preferred format for the output: Time or Unix timestamps.
+- Allow to pick your timezone when choosing time format
+- Ruby ranges are not accepted anymore as input
+- Float::INFINITY replaces Nil class to represent time infinity
+- Major architectural internal changes to improve maintainability
 
 ## 0.2.0
 - Active Support dependency removal

data/README.md

@@ -1,54 +1,177 @@
 # Availabiliter
 
-Availabiliter is a Ruby availability calculator for date ranges. It handles the following edge cases:
+Calulating gaps/availabilities between two time slots should be easy right ? Well very often it is not because of various edge cases like:
+- endless or beginless time slots
+- overlapping time slots
+- consecutive time slots
+- one second time slots
+- different time zones
 
-- endless date ranges
-- overlapping date ranges
-- consecutive date ranges
-- one day date ranges
+Availabiter is a tested and documented Ruby libary which provides an easy way of performing this calculation while handling all edge cases above.
 
-It also allows to calculate availabilities from a dedicated date in time.
+## Basic example
 
-## Installation
+For this given array of time slots...
 
-Add this line to your application's Gemfile:
+```ruby
+shift_1 = [Time.new(2021, 1, 1, 8), Time.new(2021, 1, 1, 12)]
+shift_2 = [Time.new(2021, 1, 1, 14), Time.new(2021, 1, 1, 18)]
+working_hours = [shift_1, shift_2]
+```
+
+...you can calculate the gaps between those time slots by doing the following.
 
 ```ruby
-gem 'availabiliter'
+Availabiliter.call(working_hours, format: :time)
+# returns:
+# [
+# 	[-Infinity, 2021-01-01 07:59:59 +0100],
+# 	[2021-01-01 12:00:01 +0100, 2021-01-01 13:59:59 +0100],
+# 	[2021-01-01 18:00:01 +0100, Infinity]
+# ]
 ```
 
-And then execute:
 
-    $ bundle install
+## Features
 
-Or install it yourself as:
+### Overlapping time slots
 
-    $ gem install availabiliter
+```ruby
+shift_1 = [Time.new(2021, 1, 1, 12), Time.new(2021, 1, 1, 20)]
+shift_2 = [Time.new(2021, 1, 1, 10), Time.new(2021, 1, 1, 22)]
+available_hours = [shift_1, shift_2]
+
+Availabiliter.call(working_hours, format: :time)
+# => [[-Infinity, 2021-01-01 09:59:59 +0100], [2021-01-01 22:00:01 +0100, Infinity]]
+```
+
+## Consecutive time slots
+
+```ruby
+shift_1 = [Time.new(2021, 1, 1, 12), Time.new(2021, 1, 1, 20, 0, 1)]
+shift_2 = [Time.new(2021, 1, 1, 20, 0, 1), Time.new(2021, 1, 1, 22)]
+working_hours = [shift_1, shift_2]
+
+Availabiliter.call(working_hours, format: :time)
+# => [[-Infinity, 2021-01-01 11:59:59 +0100], [2021-01-01 22:00:01 +0100, Infinity]]
+```
+
+### Endless or beginless time slots
+
+```ruby
+shift_1 = [-Float::INFINITY, Time.new(2021, 1, 1, 12)]
+shift_2 = [Time.new(2021, 1, 2, 8), Float::INFINITY]
+working_hours = [shift_1, shift_2]
+
+Availabiliter.call(working_hours, format: :time)
+# => [[2021-01-01 12:00:01 +0100, 2021-01-02 07:59:59 +0100]]
+```
+
+### Boundaries
+
+```ruby
+minimum_availability_start = Time.new(2021, 1, 1, 6)
+maximum_availability_end = Time.new(2021, 1, 1, 11)
+
+shift_1 = [Time.new(2021, 1, 1, 8), Time.new(2021, 1, 1, 12)]
+working_hours = [shift_1]
+
+Availabiliter.call(
+	working_hours,
+	minimum_availability_start: minimum_availability_start,
+	maximum_availability_end: maximum_availability_end,
+	format: :time
+)
+# => [[2021-01-01 06:00:00 +0100, 2021-01-01 07:59:59 +0100]]
+```
+
+### Format
+
+```ruby
+shift = [Time.new(2021, 1, 1, 8), Time.new(2021, 1, 1, 12)]
+working_hours = [shift]
+
+Availabiliter.call(working_hours)
+# => [[-Infinity, 1609484399], [1609498801, Infinity]]
+
+Availabiliter.call(working_hours, format: :time)
+# => [[-Infinity, 2021-01-01 07:59:59 +0100], [2021-01-01 12:00:01 +0100, Infinity]]
+```
+
+### Timezone
+
+```ruby
+time_zone = "+00:00"
+shift = [Time.new(2021, 1, 1, 8, 0, 0, time_zone), Time.new(2021, 1, 1, 12, 0, 0, time_zone)]
+working_hours = [shift]
+
+Availabiliter.call(working_hours, time_zone: "+10:00", format: :time)
+# => [[-Infinity, 2021-01-01 17:59:59 +1000], [2021-01-01 22:00:01 +1000, Infinity]]
+```
+
+When a time zone is not specifed by default Ruby determines the time zone according to the current system time.
 
 ## Usage
 
+### Expected input
+
+Expected input is an array of arrays. Each of those subarray should represent a time slot with the first element being the time slot start and the last element being the time slot end.
+A "time slot array" size should contain only 2 elements or an error will be returned.
+
 ```ruby
-# Build an array with all the date ranges you are looking an availability for
-holidays = [Date.new(1999, 1, 2)..Date.new(1999, 5, 1), Date.new(2000, 1, 1)..Date.new(2000, 2, 1), Date.new(2000, 3, 1)..nil]
+incorrect_shift = [Time.new(2021, 1, 1, 8), Time.new(2021, 1, 1, 12), Time.new(2021, 1, 1, 14)]
+working_hours = [incorrect_shift]
+
+Availabiliter.call(working_hours)
+# => Availabiliter::IncorrectInput (In the array input there is a time slot array which size is different from 2)
+```
+
+Time slot start and end should be instances of `Date`, `Time` and `Integer` classes. `Integer` in that case represent unix timestamps. 
+During calculations `Date` instances will be converted to timestamp representing the beginning of the day. Be aware that if a time zone is specified Availabiliter will take it into account while doing this conversion.
+
+### Expected output
+
+The expected output is an array of arrays, each representing an availability. Availabilities are unix timestamps by default but this can be overriden using the `format` option.
+The supported output formats are:
+- unix timestamps
+- Time instances
+
+### Infinity
+
+Time slots with an infinite start or an infinite end are supported. As input positive infinity should be represented with `Float::INFINITY`and negative infinity with `Float::INFINTIY`.
+The same values can be expected as output.
 
-Availabiliter.get_availabilities(holidays)
-# => [Date.new(1999, 5, 2)..Date.new(1999, 12, 31), Date.new(2000, 2, 2)..Date.new(2000, 2, 29)]
+### Lowest time value accepted
 
-# If you want to retrieve availabilities starting from a specific date simply add it as a second argument
-Availabiliter.get_availabilities(holidays, Date.new(1999, 12, 15))
-# => [Date.new(1999, 12, 15)..Date.new(1999, 12, 31), Date.new(2000, 2, 2)..Date.new(2000, 2, 29)]
+Since we rely on unix timestamps to deal with time zones, seconds are the lowest time value that can be accepted as an input.
 
-# If all of your date ranges have an end the last availability will be endless
-holidays = [Date.new(1999, 1, 2)..Date.new(1999, 5, 1)]
+### Performance
 
-Availabiliter.get_availabilities(holidays)
-# => [Date.new(1999, 5, 2)..]
+Benchmark done with ruby 2.7.2p137 on MacBook Pro (13-inch, M1, 2020) with an Apple M1 processor.
 
+|               | Real time per second |
+|---------------|----------------------|
+| 1000 input    | 0.004353             |
+| 10 000 input  | 0.038922             |
+| 100 000 input | 0.401442             |
+
+To do a benchmark on your machine git clone the repo and run `rake measure_performance`.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'availabiliter'
 ```
-## Future improvements
 
-- support Datetime
-- support beginless ranges
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install availabiliter
 
 ## Development
 

data/availabiliter.gemspec

@@ -28,7 +28,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "byebug", "~> 11.1.3"
+  spec.add_development_dependency "pry", "~> 0.13.1"
+  spec.add_development_dependency "pry-byebug", "~> 3.10.1"
   spec.add_development_dependency "rake", "~> 13.0.3"
   spec.add_development_dependency "rspec", "~> 3.10"
   spec.add_development_dependency "rubocop", "~> 1.16.1"

data/bin/console

@@ -12,4 +12,10 @@ require "availabiliter"
 # Pry.start
 
 require "irb"
+
+# http://www.seanbehan.com/ruby-reload-method-in-non-rails-irb-sessions/
+def reload!
+  Dir["./lib/**/*.rb"].each { |f| load(f) }
+end
+
 IRB.start(__FILE__)

data/lib/availabiliter/availabilities_calculator.rb

@@ -0,0 +1,41 @@
+require_relative "output_formatter"
+require_relative "input_formatter"
+require_relative "time_slot_collection"
+
+class Availabiliter
+  # Centralize and orchestrate all behavior for availabilities calculations
+  class AvailabilitiesCalculator
+    attr_reader :raw_time_slots, :minimum_availability_start, :maximum_availability_end, :format, :time_zone
+
+    def initialize(raw_time_slots, minimum_availability_start:, maximum_availability_end:, format:, time_zone:)
+      @raw_time_slots = raw_time_slots
+      @minimum_availability_start = minimum_availability_start
+      @maximum_availability_end = maximum_availability_end
+      @format = format
+      @time_zone = time_zone
+    end
+
+    def call
+      output_availabilities
+    end
+
+    private
+
+    def time_slots
+      InputFormatter.new(input_array: raw_time_slots, time_zone: time_zone).time_slots
+    end
+
+    def availabilities
+      time_slot_collection.availabilities
+    end
+
+    def output_availabilities
+      OutputFormatter.new(availabilities, format: format, time_zone: time_zone).format_availabilities
+    end
+
+    def time_slot_collection
+      TimeSlotCollection.new(time_slots: time_slots, minimum_availability_start: minimum_availability_start,
+                             maximum_availability_end: maximum_availability_end)
+    end
+  end
+end

data/lib/availabiliter/errors.rb

@@ -0,0 +1,5 @@
+class Availabiliter
+  class Error < ::StandardError; end
+
+  class IncorrectInput < Error; end
+end

data/lib/availabiliter/input_formatter.rb

@@ -0,0 +1,48 @@
+require_relative "time_slot"
+
+class Availabiliter
+  # Convert raw time slots to TimeSlot instances
+  class InputFormatter
+    attr_reader :input_array, :time_zone
+
+    def initialize(input_array:, time_zone:)
+      @input_array = input_array
+      @time_zone = time_zone
+    end
+
+    def time_slots
+      input_array.map do |time_slot_input|
+        validate_time_slot_input(time_slot_input)
+
+        TimeSlot.new(starting_time: to_timestamp(time_slot_input.first),
+                     ending_time: to_timestamp(time_slot_input.last))
+      end
+    end
+
+    private
+
+    def validate_time_slot_input(time_slot_input)
+      return if  time_slot_input.size == 2
+
+      raise IncorrectInput, "In the array input there is a time slot array which size is different from 2"
+    end
+
+    def to_timestamp(value)
+      case value.class.to_s
+      when "Time" then value.to_i
+      when "Date"
+        convert_date(value)
+      else
+        value
+      end
+    end
+
+    def convert_date(date)
+      if time_zone
+        Time.new(date.year, date.month, date.day, 0, 0, 0, time_zone).to_i
+      else
+        date.to_time.to_i
+      end
+    end
+  end
+end

data/lib/availabiliter/options_validator.rb

@@ -0,0 +1,56 @@
+class Availabiliter
+  # Verify that the options input are valid
+  class OptionsValidator
+    attr_reader :minimum_availability_start, :maximum_availability_end, :format
+
+    def initialize(minimum_availability_start:, maximum_availability_end:, format:, **_options)
+      @minimum_availability_start = minimum_availability_start
+      @maximum_availability_end = maximum_availability_end
+      @format = format
+    end
+
+    def call
+      validate_format
+      validate_boundary_class
+      validate_boundary_value
+    end
+
+    private
+
+    def validate_format
+      return if PROCESSABLE_FORMATS.include?(format)
+
+      raise IncorrectInput, "#{format} is not an available format"
+    end
+
+    def validate_boundary_class
+      raise_invalid_boundary_class if invalid_boundary_class?
+    end
+
+    def invalid_boundary_class?
+      [minimum_availability_start, maximum_availability_end].one? do |boundary|
+        PROCESSABLE_TIME_CLASSES.none? { |klass| klass == boundary.class }
+      end
+    end
+
+    def validate_boundary_value
+      raise_invalid_boundary_value if invalid_boundary_value?
+    end
+
+    def invalid_boundary_value?
+      minimum_availability_start > maximum_availability_end
+    end
+
+    def raise_invalid_boundary_class
+      raise IncorrectInput, invalid_boundary_class_message
+    end
+
+    def raise_invalid_boundary_value
+      raise IncorrectInput, "minimum_availability_start can't be greater than maximum_availability_end"
+    end
+
+    def invalid_boundary_class_message
+      "#{minimum_availability_start.class}, #{maximum_availability_end.class} : one of this boundary class is not valid"
+    end
+  end
+end

data/lib/availabiliter/output_formatter.rb

@@ -0,0 +1,42 @@
+class Availabiliter
+  # Transform availabilities to the required format
+  class OutputFormatter
+    attr_reader :availabilities, :format, :time_zone
+
+    def initialize(availabilities, format:, time_zone:)
+      @availabilities = availabilities
+      @format = format
+      @time_zone = time_zone
+    end
+
+    def format_availabilities
+      availabilities.map do |availability|
+        convert_to_format(availability)
+      end
+    end
+
+    private
+
+    def convert_to_format(availability)
+      [convert_timestamp(availability.first), convert_timestamp(availability.last)]
+    end
+
+    def convert_timestamp(timestamp)
+      return timestamp if timestamp.infinite?
+
+      case format
+      when :time then convert_time(timestamp)
+      else
+        timestamp
+      end
+    end
+
+    def convert_time(timestamp)
+      if time_zone
+        Time.at(timestamp, in: time_zone)
+      else
+        Time.at(timestamp)
+      end
+    end
+  end
+end

data/lib/availabiliter/time_slot.rb

@@ -0,0 +1,50 @@
+class Availabiliter
+  # A TimeSlot represent a slot in time with a start and an end that can be finite or infinite.
+  # It can also act as a boundary in availabilities calculation.
+  class TimeSlot
+    attr_reader :starting_time, :ending_time, :boundary
+
+    def initialize(starting_time:, ending_time:, boundary: false)
+      @starting_time = starting_time
+      @ending_time = ending_time
+      @boundary = boundary
+      validate
+    end
+
+    def furthest(other)
+      [self, other].max_by(&:ending_time)
+    end
+
+    def dependent?(other)
+      adjacent?(other) || overlaps?(other)
+    end
+
+    def next_second
+      ending_time + 1
+    end
+
+    def previous_second
+      starting_time - 1
+    end
+
+    def overlaps?(other)
+      !does_not_overlap?(other)
+    end
+
+    def does_not_overlap?(other)
+      starting_time > other.ending_time || ending_time < other.starting_time
+    end
+
+    def adjacent?(other)
+      other.ending_time == previous_second || other.starting_time == next_second
+    end
+
+    private
+
+    def validate
+      return if ending_time >= starting_time
+
+      raise IncorrectInput, "A time slot ending time must be equal or greater than its starting time"
+    end
+  end
+end

data/lib/availabiliter/time_slot_collection.rb

@@ -0,0 +1,58 @@
+require_relative "time_slot"
+require "forwardable"
+
+class Availabiliter
+  # A time slot collection is a sorted collection of time slots with a start and an end boundary
+  class TimeSlotCollection
+    include Enumerable
+    attr_reader :collection
+
+    def initialize(time_slots:, minimum_availability_start:, maximum_availability_end:)
+      @minimum_availability_start = minimum_availability_start
+      @maximum_availability_end = maximum_availability_end
+      @collection = build_collection(time_slots)
+    end
+
+    def availabilities
+      furthest_time_slot = start_boundary
+
+      filter_map.with_index do |time_slot, index|
+        next_time_slot = collection[index + 1]
+        furthest_time_slot = time_slot.furthest(furthest_time_slot)
+
+        next if index == last_time_slot_index
+        next if furthest_time_slot.dependent?(next_time_slot)
+
+        [furthest_time_slot.next_second, next_time_slot.previous_second]
+      end
+    end
+
+    private
+
+    attr_reader :minimum_availability_start, :maximum_availability_end
+
+    def build_collection(time_slots)
+      time_slots.then do |array|
+        array.sort_by!(&:starting_time)
+        array.unshift(start_boundary)
+        array.push(end_boundary)
+      end
+    end
+
+    def each(&block)
+      collection.each(&block)
+    end
+
+    def start_boundary
+      TimeSlot.new(starting_time: -Float::INFINITY, ending_time: minimum_availability_start - 1, boundary: true)
+    end
+
+    def end_boundary
+      TimeSlot.new(starting_time: maximum_availability_end + 1, ending_time: Float::INFINITY, boundary: true)
+    end
+
+    def last_time_slot_index
+      @last_time_slot_index ||= count - 1
+    end
+  end
+end

data/lib/availabiliter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module Availabiliter
-  VERSION = "0.2.0"
+class Availabiliter
+  VERSION = "1.0.0"
 end

data/lib/availabiliter.rb

@@ -1,13 +1,46 @@
-# frozen_string_literal: true
-
 require_relative "availabiliter/version"
-require_relative "availabiliter/timeframe"
+require_relative "availabiliter/availabilities_calculator"
+require_relative "availabiliter/errors"
+require_relative "availabiliter/options_validator"
+require "date"
+
+# Availabilityer main class and namespace
+class Availabiliter
+  PROCESSABLE_FORMATS = %i[time integer].freeze
+  DEFAULT_FORMAT = :integer
+  PROCESSABLE_TIME_CLASSES = [Date, Time, Integer, Float].freeze
 
-# Availability calculator class
-module Availabiliter
   class << self
-    def get_availabilities(array, timeframe_start = nil)
-      TimeFrame.new(array, timeframe_start).availabilities
+    def call(raw_time_slots, **options)
+      new(raw_time_slots, options).calculate
     end
   end
+
+  def initialize(raw_time_slots, options)
+    @options = default_options.merge(options)
+    @raw_time_slots = raw_time_slots
+
+    validate_options
+  end
+
+  def calculate
+    AvailabilitiesCalculator.new(raw_time_slots, **options).call
+  end
+
+  private
+
+  attr_reader :raw_time_slots, :options
+
+  def default_options
+    {
+      minimum_availability_start: -Float::INFINITY,
+      maximum_availability_end: Float::INFINITY,
+      format: DEFAULT_FORMAT,
+      time_zone: nil
+    }
+  end
+
+  def validate_options
+    OptionsValidator.new(options).call
+  end
 end

data/rakelib/measure_performance.rake

@@ -0,0 +1,31 @@
+require "benchmark"
+require "date"
+require_relative "../lib/availabiliter"
+
+desc "Benchmark easily the performance of gem"
+task :measure_performance do
+  Benchmark.bm do |benchmark|
+    raw_time_slots = build_raw_time_slots(1000)
+    benchmark.report(:one_thousand_raw_time_slots) { Availabiliter.call(raw_time_slots) }
+
+    raw_time_slots = build_raw_time_slots(10_000)
+    benchmark.report(:ten_thousand_raw_time_slots) { Availabiliter.call(raw_time_slots) }
+
+    raw_time_slots = build_raw_time_slots(100_000)
+    benchmark.report(:one_hundrer_thousand_raw_time_slots) { Availabiliter.call(raw_time_slots) }
+  end
+end
+
+def build_raw_time_slots(number)
+  date_range = Date.new(2020, 1, 1)..Date.new(2030, 1, 1)
+  timestamp_range = 1_577_833_200..1_893_452_400
+  time_range = Time.new(2020, 1, 1)..Time.new(2030, 1, 1)
+  rand_array = [date_range, timestamp_range, time_range]
+
+  number.times.each_with_object([]) do |_i, array|
+    starting_time = Random.rand(rand_array.sample)
+    finish_time = starting_time + Random.rand(1000)
+
+    array << [starting_time, finish_time]
+  end
+end

data/rakelib/test_ruby_versions.rake

@@ -0,0 +1,13 @@
+require "date"
+require_relative "../lib/availabiliter"
+
+desc "Run the tests against all ruby versions"
+task :test_ruby_versions do
+  authorized_versions = ["3.1.2", "3.0.4", "2.7.6", "2.7.2"]
+
+  authorized_versions.each do |version|
+    print "---------RUNNING TEST FOR RUBY #{version}---------"
+    system("export RBENV_VERSION=#{version} && bundle install && bundle exec rspec --fail-fast --format progress && export RBENV_VERSION=")
+    print "--------------------------------------------------"
+  end
+end

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: availabiliter
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - lioneldebauge
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-09-04 00:00:00.000000000 Z
+date: 2022-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 11.1.3
+        version: 0.13.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 11.1.3
+        version: 0.13.1
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -86,9 +100,16 @@ files:
 - bin/console
 - bin/setup
 - lib/availabiliter.rb
-- lib/availabiliter/date_range.rb
-- lib/availabiliter/timeframe.rb
+- lib/availabiliter/availabilities_calculator.rb
+- lib/availabiliter/errors.rb
+- lib/availabiliter/input_formatter.rb
+- lib/availabiliter/options_validator.rb
+- lib/availabiliter/output_formatter.rb
+- lib/availabiliter/time_slot.rb
+- lib/availabiliter/time_slot_collection.rb
 - lib/availabiliter/version.rb
+- rakelib/measure_performance.rake
+- rakelib/test_ruby_versions.rake
 homepage: https://github.com/lioneldebauge/availabiliter.git
 licenses:
 - MIT

data/lib/availabiliter/date_range.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-
-module Availabiliter
-  # DateRange is a Range with only dates
-  # DateRange start_date is always the earliest date and end_date the latest date
-  class DateRange < Range
-    include Comparable
-
-    alias start_date begin
-    alias end_date end
-
-    def initialize(start_date, end_date)
-      super
-      raise ArgumentError, "bad value for DateRange" unless valid?
-    end
-
-    def independent?(other)
-      return true if other.nil?
-
-      !overlaps?(other) && !adjacent?(other)
-    end
-
-    def tomorrow
-      end_date&.next_day
-    end
-
-    def yesterday
-      start_date.prev_day
-    end
-
-    ## adjacent == touches but doesn't overlap other DateRange
-    def adjacent?(other)
-      return other.end_date == yesterday if end_date.nil?
-
-      other.end_date == yesterday || other.start_date == tomorrow
-    end
-
-    def overlaps?(other)
-      cover?(other.begin) || other.cover?(first)
-    end
-
-    def next_availability(next_date_range)
-      return if end_date.nil?
-      return tomorrow..nil if next_date_range.nil?
-      return unless independent?(next_date_range)
-
-      gap_start = tomorrow
-      gap_end = next_date_range.yesterday
-
-      gap_start..gap_end
-    end
-
-    def furthest(other)
-      return self if end_date.nil? || other.nil?
-      return other if other.end_date.nil?
-
-      [self, other].max_by(&:end_date)
-    end
-
-    private
-
-    def valid?
-      start_date.instance_of?(Date) && (end_date.nil? || start_date < end_date)
-    end
-  end
-end

data/lib/availabiliter/timeframe.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "date_range"
-
-module Availabiliter
-  # A TimeFrame is an object representing several DateRange instances. It can have a start.
-  # It can have only one endless DateRange.
-  class TimeFrame
-    attr_reader :start_date, :date_ranges
-
-    def initialize(array, start_date = nil)
-      @start_date = start_date
-      @date_ranges = build_date_ranges(array)
-
-      raise ArgumentError unless valid?
-    end
-
-    def availabilities
-      return [start_date..nil] if date_ranges.empty?
-      return build_availabilities if start_date.nil?
-
-      availabilities = build_availabilities
-      start_date < first_date_range.start_date ? availabilities.unshift(first_availability) : availabilities
-    end
-
-    private
-
-    def build_date_ranges(array)
-      date_range_array = array.filter_map do |range|
-        next if out_of_timeframe?(range.end)
-
-        DateRange.new(range.begin, range.end)
-      end
-
-      date_range_array.sort_by(&:start_date)
-    end
-
-    def build_availabilities
-      furthest_date_range = first_date_range
-
-      date_ranges.filter_map.with_index do |date_range, index|
-        next_date_range = date_ranges[index + 1]
-
-        furthest_date_range = furthest_date_range.furthest(date_range)
-        furthest_date_range.next_availability(next_date_range)
-      end
-    end
-
-    def out_of_timeframe?(range_end)
-      !start_date.nil? && (!range_end.nil? && range_end < start_date)
-    end
-
-    def first_availability
-      start_date..first_date_range.yesterday
-    end
-
-    def first_date_range
-      date_ranges.first
-    end
-
-    def valid?
-      end_date_valid? && date_ranges.count { |date_range| date_range.end_date.nil? } <= 1
-    end
-
-    def end_date_valid?
-      start_date.instance_of?(Date) || start_date.instance_of?(NilClass)
-    end
-  end
-end