acts_as_bookable 0.1.0

data/lib/acts_as_bookable/time_utils.rb

@@ -0,0 +1,135 @@
+module ActsAsBookable
+  ##
+  # Provide helper functions to manage operations and queries related to times
+  # and schedules
+  #
+  module TimeUtils
+    class << self
+      ##
+      # Check if time is included in a time interval. The ending time is excluded
+      #
+      # @param time The time to check
+      # @param interval_start The beginning time of the interval to match against
+      # @param interval_end The ending time of the interval to match against
+      #
+      def time_in_interval? (time, interval_start, interval_end)
+        time >= interval_start && time < interval_end
+      end
+
+      ##
+      # Check if there is an occurrence of a schedule that contains a time interval
+      #
+      # @param schedule The schedule
+      # @param interval_start The beginning Time of the interval
+      # @param interval_end The ending Time of the interval
+      # @return true if the interval falls within an occurrence of the schedule, otherwise false
+      #
+      def interval_in_schedule?(schedule, interval_start, interval_end)
+        # Check if interval_start and interval_end falls within any occurrence
+        return false if(!time_in_schedule?(schedule,interval_start) || !time_in_schedule?(schedule,interval_end))
+
+        # Check if both interval_start and interval_end falls within the SAME occurrence
+        between = schedule.occurrences_between(interval_start, interval_end, true)
+        contains = false
+        between.each do |oc|
+          oc_end = oc + schedule.duration
+          contains = true if (time_in_interval?(interval_start,oc,oc_end) && time_in_interval?(interval_end,oc,oc_end))
+          break if contains
+        end
+
+        contains
+      end
+
+      ##
+      # Check if there is an occurrence of a schedule that contains a time
+      # @param schedule The schedule
+      # @param time The time
+      # @return true if the time falls within an occurrence of the schedule, otherwise false
+      #
+      def time_in_schedule?(schedule, time)
+        return schedule.occurring_at? time
+      end
+
+      ##
+      # Returns an array of sub-intervals given another array of intervals, which are the overlapping insersections of each-others.
+      #
+      # @param intervals an array of intervals
+      # @return an array of subintervals, sorted by time_start
+      #
+      # An interval is defined as a hash with at least the following fields: `time_from` and `time_end`. An interval may contain more
+      # fields. In that case, it's suggested to give a block with the instructions to correctly merge two intervals when needed.
+      #
+      # e.g: given these 7 intervals
+      #   |------|    |---|       |----------|
+      #      |---|          |--|
+      #      |------|       |--|      |-------------|
+      #   the output is an array containing these 8 intervals:
+      #   |--|   |--| |---| |--|  |---|      |------|
+      #      |---|                    |------|
+      #   the number of subintervals may increase or decrease because some intervals may be split, while
+      #   some others may be merged.
+      #
+      # If a block is given, it's called before merging two intervals. The block should provide instructions to merge intervals, and should return the merged fields in a hash
+      def subintervals(intervals, &block)
+        raise ArgumentError.new('intervals must be an array') unless intervals.is_a? Array
+
+        steps = [] # Steps will be extracted from intervals
+        subintervals = [] # The output
+        last_time = nil
+        last_attrs = nil
+        started_count = 0 # The number of intervals opened inside the cycle
+
+        # Extract start times and end times from intervals, and create steps
+        intervals.each do |el|
+          begin
+            ts = el[:time_start].to_time
+            te = el[:time_end].to_time
+          rescue NoMethodError
+            raise ArgumentError.new('intervals must define :time_start and :time_end as Time or Date')
+          end
+          attrs = el.clone
+          attrs.delete(:time_start)
+          attrs.delete(:time_end)
+          steps << { opening: 1, time: el[:time_start], attrs: attrs } # Start step
+          steps << { opening: -1, time: el[:time_end], attrs: attrs.clone } # End step
+        end
+
+        # Sort steps by time (and opening if time is the same)
+        steps.sort! do |a,b|
+          diff = a[:time] <=> b[:time]
+          diff = a[:opening] <=> b[:opening] if (diff == 0)
+          diff
+        end
+
+        # Iterate over steps
+        steps.each do |step|
+          if (started_count == 0)
+            last_time = step[:time]
+            last_attrs = step[:attrs]
+          else
+            if(step[:time] > last_time)
+              subintervals << ({
+                time_start: last_time,
+                time_end: step[:time]
+              }.merge(last_attrs))
+
+              last_time = step[:time]
+            end
+
+            if block_given?
+              last_attrs = block.call(last_attrs.clone, step[:attrs],(step[:opening] == 1 ? :open : :close))
+            else
+              last_attrs = step[:attrs]
+            end
+          end
+
+          # Update started_count
+          started_count += step[:opening]
+        end
+
+        subintervals
+      end
+
+    end
+  end
+end

data/lib/acts_as_bookable/version.rb

@@ -0,0 +1,3 @@
+module ActsAsBookable
+  VERSION = "0.1.0"
+end

data/lib/acts_as_bookable.rb

@@ -0,0 +1,42 @@
+require 'active_record'
+require 'active_record/version'
+require 'active_support/core_ext/module'
+require_relative 'acts_as_bookable/engine'  if defined?(Rails)
+require 'ice_cube'
+IceCube.compatibility = 12 # Drop compatibility for :start_date, avoiding a bunch of warnings caused by serialization
+
+module ActsAsBookable
+  extend ActiveSupport::Autoload
+
+  autoload :Bookable
+  autoload :Booker
+  autoload :Booking
+  autoload :T
+  autoload :VERSION
+  autoload :TimeUtils
+  autoload :DBUtils
+
+  autoload_under 'bookable' do
+    autoload :Core
+  end
+
+  class InitializationError < StandardError
+    def initialize model, message
+      super "Error initializing acts_as_bookable on #{model.to_s} - " + message
+    end
+  end
+
+  class OptionsInvalid < StandardError
+    def initialize model, message
+      super "Error validating options for #{model.to_s} - " + message
+    end
+  end
+
+  class AvailabilityError < StandardError
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  extend ActsAsBookable::Bookable
+  include ActsAsBookable::Booker
+end

data/lib/tasks/acts_as_bookable_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :acts_as_bookable do
+#   # Task goes here
+# end

data/spec/acts_as_bookable/acts_as_bookable_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe 'acts_as_bookable' do
+  it "should provide a class method 'bookable?' that is false for unbookable models" do
+    expect(Unbookable).not_to be_bookable
+  end
+
+  describe 'Bookable Method Generation' do
+    before :each do
+      Unbookable.acts_as_bookable
+      @bookable = Unbookable.new()
+    end
+
+    it "should respond 'true' to bookable?" do
+      expect(@bookable.class).to be_bookable
+    end
+  end
+
+  describe 'class configured as Bookable' do
+    before(:each) do
+      @bookable = Bookable.new
+    end
+
+    it 'should add #bookable? query method to the class-side' do
+      expect(Bookable).to respond_to(:bookable?)
+    end
+
+    it 'should return true from the class-side #bookable?' do
+      expect(Bookable.bookable?).to be_truthy
+    end
+
+    it 'should return false from the base #bookable?' do
+      expect(ActiveRecord::Base.bookable?).to be_falsy
+    end
+
+    # it 'should add #tag method on the instance-side' do
+    #   expect(@bookable).to respond_to(:tag)
+    # end
+
+    # it 'should generate an association for #owned_taggings and #owned_tags' do
+    #   expect(@bookable).to respond_to(:owned_taggings, :owned_tags)
+    # end
+  end
+
+  describe 'Reloading' do
+    it 'should save a model instantiated by Model.find' do
+      bookable = create(:bookable)
+      found_bookable = Bookable.find(bookable.id)
+      expect(found_bookable.save).to eq true
+    end
+  end
+end

data/spec/acts_as_bookable/acts_as_booker_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe 'acts_as_booker' do
+  it "should provide a class method 'booker?' that is false for not booker models" do
+    expect(NotBooker).not_to be_booker
+  end
+
+  describe 'Booker Method Generation' do
+    before :each do
+      NotBooker.acts_as_booker
+      @booker = NotBooker.new()
+    end
+
+    it "should respond 'true' to booker?" do
+      expect(@booker.class).to be_booker
+    end
+  end
+
+  describe 'class configured as Booker' do
+    before(:each) do
+      @booker = Booker.new
+    end
+
+    it 'should add #booker? query method to the class-side' do
+      expect(Booker).to respond_to(:booker?)
+    end
+
+    it 'should return true from the class-side #booker?' do
+      expect(Booker.booker?).to be_truthy
+    end
+
+    it 'should return false from the base #booker?' do
+      expect(ActiveRecord::Base.booker?).to be_falsy
+    end
+
+    it 'should add #booker? query method to the instance-side' do
+      expect(@booker).to respond_to(:booker?)
+    end
+
+    it 'should add #booker? query method to the instance-side' do
+      expect(@booker.booker?).to be_truthy
+    end
+
+
+    # it 'should generate an association for #owned_taggings and #owned_tags' do
+    #   expect(@booker).to respond_to(:owned_taggings, :owned_tags)
+    # end
+  end
+
+  describe 'Reloading' do
+    it 'should save a model instantiated by Model.find' do
+      booker = Booker.create!(name: 'Booker')
+      found_booker = Booker.find(booker.id)
+      expect(found_booker.save).to eq true
+    end
+  end
+end