active_bookings 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a094c563d3e4de794dafa566582dc5d0cc3511bc0c7397b4a50f49346dd4ba0
+  data.tar.gz: 23746232c3e41bcddd9b11db629ce8a077b024e5df83b091e342fa7f765d2039
+SHA512:
+  metadata.gz: 64c45f54e6f47f27a5b019ee139ae5c99b21cb1ef511ef0d38a61979b796caedaf8ca2eaeea1c1f705791db238045c690a068f1cb9057473aa5a34af7fc25dbe
+  data.tar.gz: 1386a8ccd484468fe6da08051735c10d87645e59107fb4a8a8b92c7509b573f12a876464f1915a68729ee46839aa7cbceef932ec67ada9f6832dcf0bc8a05243

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at info@hardpixel.eu. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in smart_navigation.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Jonian Guveli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# ActiveBookings
+
+Make ActiveRecord models bookable with availability rules, schedule etc.
+
+[![Gem Version](https://badge.fury.io/rb/active_bookings.svg)](https://badge.fury.io/rb/active_bookings)
+[![Build Status](https://travis-ci.org/hardpixel/active-bookings.svg?branch=master)](https://travis-ci.org/hardpixel/active-bookings)
+[![Maintainability](https://api.codeclimate.com/v1/badges/22f68b2e62b222e7efae/maintainability)](https://codeclimate.com/github/hardpixel/active-bookings/maintainability)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_bookings'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_bookings
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/hardpixel/active-bookings. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the ActiveBookings project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/hardpixel/active-bookings/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/lib/active_bookings.rb

@@ -0,0 +1,42 @@
+require 'active_record'
+require 'active_record/version'
+require 'active_support/core_ext/module'
+require 'ice_cube'
+
+IceCube.compatibility = 12 # Drop compatibility for :start_date, avoiding a bunch of warnings caused by serialization
+
+module ActiveBookings
+  extend ActiveSupport::Autoload
+
+  autoload :Serializer
+  autoload :Bookable
+  autoload :Booker
+  autoload :Booking
+  autoload :VERSION
+  autoload :TimeUtils
+  autoload :DBUtils
+
+  autoload_under 'bookable' do
+    autoload :Core
+  end
+
+  class InitializationError < StandardError
+    def initialize model, message
+      super "Error initializing active_bookings 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 ActiveBookings::Bookable
+  include ActiveBookings::Booker
+end

data/lib/active_bookings/bookable.rb

@@ -0,0 +1,54 @@
+module ActiveBookings
+  module Bookable
+
+    def bookable?
+      false
+    end
+
+    ##
+    # Make a model bookable
+    #
+    # Example:
+    #   class Room < ActiveRecord::Base
+    #     is_bookable
+    #   end
+    def is_bookable(options={})
+      bookable(options)
+    end
+
+    private
+
+    # Make a model bookable
+    def bookable(options)
+      assoc_class_name = options.delete(:class_name) || '::ActiveBookings::Booking'
+
+      if bookable?
+        self.booking_opts = options
+      else
+        class_attribute :booking_opts
+        self.booking_opts = options
+
+        class_eval do
+          serialize :schedule, ActiveBookings::Serializer
+          has_many :bookings, as: :bookable, dependent: :destroy, class_name: assoc_class_name
+
+          validates_numericality_of :capacity, if: :capacity?, only_integer: true, greater_than_or_equal_to: 0
+
+          def self.bookable?
+            true
+          end
+
+          def schedule_required?
+            self.booking_opts && self.booking_opts && self.booking_opts[:time_type] != :none
+          end
+
+          def capacity_required?
+            self.booking_opts && self.booking_opts[:capacity_type] != :none
+          end
+        end
+      end
+
+      include Core
+    end
+  end
+end

data/lib/active_bookings/bookable/core.rb

@@ -0,0 +1,298 @@
+module ActiveBookings::Bookable
+  module Core
+    def self.included(base)
+      base.extend ActiveBookings::Bookable::Core::ClassMethods
+      base.send :include, ActiveBookings::Bookable::Core::InstanceMethods
+
+      base.initialize_active_bookings_core
+    end
+
+    module ClassMethods
+      ##
+      # Initialize the core of Bookable
+      #
+      def initialize_active_bookings_core
+        # Manage the options
+        set_options
+      end
+
+      ##
+      # Check if options passed for booking this Bookable are valid
+      #
+      # @raise ActiveBookings::OptionsInvalid if options are not valid
+      #
+      def validate_booking_options!(options)
+        unpermitted_params = []
+        required_params = {}
+
+        #
+        # Set unpermitted parameters and required parameters depending on Bookable options
+        #
+
+        # Switch :time_type
+        case self.booking_opts[:time_type]
+        # when :range, we need :time_start and :time_end
+        when :range
+          required_params[:time_start] = [Time,Date]
+          required_params[:time_end] = [Time,Date]
+          unpermitted_params << :time
+        when :fixed
+          required_params[:time] = [Time,Date]
+          unpermitted_params << :time_start
+          unpermitted_params << :time_end
+        when :none
+          unpermitted_params << :time_start
+          unpermitted_params << :time_end
+          unpermitted_params << :time
+        end
+
+        # Switch :capacity_type
+        case self.booking_opts[:capacity_type]
+        when :closed
+          required_params[:amount] = [Integer]
+        when :open
+          required_params[:amount] = [Integer]
+        when :none
+          unpermitted_params << :amount
+        end
+
+        #
+        # Actual validation
+        #
+        unpermitted_params = unpermitted_params
+          .select{ |p| options.has_key?(p) }
+          .map{ |p| "'#{p}'"}
+        wrong_types = required_params
+          .select{ |k,v| options.has_key?(k) && (v.select{|type| options[k].is_a?(type)}.length == 0) }
+          .map{ |k,v| "'#{k}' must be a '#{v.join(' or ')}' but '#{options[k].class.to_s}' found" }
+        required_params = required_params
+          .select{ |k,v| !options.has_key?(k) }
+          .map{ |k,v| "'#{k}'" }
+
+        #
+        # Raise OptionsInvalid if some invalid parameters were found
+        #
+        if unpermitted_params.length + required_params.length + wrong_types.length > 0
+          message = ""
+          message << " unpermitted parameters: #{unpermitted_params.join(',')}." if (unpermitted_params.length > 0)
+          message << " missing parameters: #{required_params.join(',')}." if (required_params.length > 0)
+          message << " parameters type mismatch: #{wrong_types.join(',')}" if (wrong_types.length > 0)
+          raise ActiveBookings::OptionsInvalid.new(self, message)
+        end
+
+        #
+        # Convert options (Date to Time)
+        #
+        options[:time_start] = options[:time_start].to_time if options[:time_start].present?
+        options[:time_end] = options[:time_end].to_time if options[:time_end].present?
+        options[:time] = options[:time].to_time if options[:time].present?
+
+        # Return true if everything's ok
+        true
+      end
+
+      private
+        ##
+        # Set the options
+        #
+        def set_options
+          # The default preset is 'room'
+          self.booking_opts[:preset]
+
+          defaults = nil
+
+          # Validates options
+          permitted_options = {
+            time_type: [:range, :fixed, :none],
+            capacity_type: [:open, :closed, :none],
+            preset: [:room, :event, :show],
+            bookable_across_occurrences: [true, false]
+          }
+          self.booking_opts.each_pair do |key, val|
+            if !permitted_options.has_key? key
+              raise ActiveBookings::InitializationError.new(self, "#{key} is not a valid option")
+            elsif !permitted_options[key].include? val
+              raise ActiveBookings::InitializationError.new(self, "#{val} is not a valid value for #{key}. Allowed values are: #{permitted_options[key]}")
+            end
+          end
+
+          case self.booking_opts[:preset]
+          # Room preset
+          when :room
+            defaults = {
+              time_type: :range,      # time_start is check-in, time_end is check-out
+              capacity_type: :closed,  # capacity is closed: after the first booking the room is not bookable anymore, even though the capacity has not been reached
+              bookable_across_occurrences: true # a room is bookable across recurrences: if a recurrence is daily, a booker must be able to book from a date to another date, even though time_start and time_end falls in different occurrences of the schedule
+            }
+          # Event preset (e.g. a birthday party)
+          when :event
+            defaults = {
+              time_type: :none,       # time is ininfluent for booking an event.
+              capacity_type: :open,    # capacity is open: after a booking the event is still bookable until capacity is reached.
+              bookable_across_occurrences: false # an event is not bookable across recurrences
+            }
+          # Show preset (e.g. a movie)
+          when :show
+            defaults = {
+              time_type: :fixed,      # time is fixed: a user chooses the time of the show (the show may have a number of occurrences)
+              capacity_type: :open,    # capacity is open: after a booking the show is still bookable until capacity is reached
+              bookable_across_occurrences: false # a show is not bookable across recurrences
+            }
+          else
+            defaults = {
+              time_type: :none,
+              capacity_type: :none,
+              bookable_across_occurrences: false
+            }
+          end
+
+          # Merge options with defaults
+          self.booking_opts.reverse_merge!(defaults)
+        end
+    end
+
+    module InstanceMethods
+      ##
+      # Check availability of current bookable, raising an error if the bookable is not available
+      #
+      # @param opts The booking options
+      # @return true if the bookable is available for given options
+      # @raise ActiveBookings::AvailabilityError if the bookable is not available for given options
+      #
+      # Example:
+      #   @room.check_availability!(from: Date.today, to: Date.tomorrow, amount: 2)
+      def check_availability!(opts)
+        # validates options
+        self.validate_booking_options!(opts)
+
+        # Capacity check (done first because it doesn't require additional queries)
+        if self.booking_opts[:capacity_type] != :none
+          # Amount > capacity
+          if opts[:amount] > self.capacity
+            error = I18n.t('.active_bookings.availability.amount_gt_capacity', model: self.class.to_s)
+            raise ActiveBookings::AvailabilityError.new error
+          end
+        end
+
+        ##
+        # Time check
+        #
+        if self.booking_opts[:time_type] == :range
+          time_check_ok = true
+          # If it's bookable across recurrences, just check start time and end time
+          if self.booking_opts[:bookable_across_occurrences]
+            # Check start time
+            if !(ActiveBookings::TimeUtils.time_in_schedule?(self.schedule, opts[:time_start]))
+              time_check_ok = false
+            end
+            # Check end time
+            if !(ActiveBookings::TimeUtils.time_in_schedule?(self.schedule, opts[:time_end]))
+              time_check_ok = false
+            end
+          # If it's not bookable across recurrences, check if the whole interval is included in an occurrence
+          else
+            # Check the whole interval
+            if !(ActiveBookings::TimeUtils.interval_in_schedule?(self.schedule, opts[:time_start], opts[:time_end]))
+              time_check_ok = false
+            end
+          end
+          # If something went wrong
+          unless time_check_ok
+            error = I18n.t('.active_bookings.availability.unavailable_interval', model: self.class.to_s, time_start: opts[:time_start], time_end: opts[:time_end])
+            raise ActiveBookings::AvailabilityError.new error
+          end
+        end
+        if self.booking_opts[:time_type] == :fixed
+          if !(ActiveBookings::TimeUtils.time_in_schedule?(self.schedule, opts[:time]))
+            error = I18n.t('.active_bookings.availability.unavailable_time', model: self.class.to_s, time: opts[:time])
+            raise ActiveBookings::AvailabilityError.new error
+          end
+        end
+
+        ##
+        # Real capacity check (calculated with overlapped bookings)
+        #
+        overlapped = ActiveBookings::Booking.overlapped(self, opts)
+        # If capacity_type is :closed cannot book if already booked (no matter if amount < capacity)
+        if (self.booking_opts[:capacity_type] == :closed && !overlapped.empty?)
+          error = I18n.t('.active_bookings.availability.already_booked', model: self.class.to_s)
+          raise ActiveBookings::AvailabilityError.new error
+        end
+        # if capacity_type is :open, check if amount <= maximum amount of overlapped booking
+        if (self.booking_opts[:capacity_type] == :open && !overlapped.empty?)
+          # if time_type is :range, split in sub-intervals and check the maximum sum of amounts against capacity for each sub-interval
+          if (self.booking_opts[:time_type] == :range)
+            # Map overlapped bookings to a set of intervals with amount
+            intervals = overlapped.map { |e| {time_start: e.time_start, time_end: e.time_end, amount: e.amount} }
+            # Make subintervals from overlapped bookings and check capacity for each of them
+            ActiveBookings::TimeUtils.subintervals(intervals) do |a,b,op|
+              case op
+              when :open
+                res = {amount: a[:amount] + b[:amount]}
+              when :close
+                res = {amount: a[:amount] - b[:amount]}
+              end
+
+              if (res[:amount] >= self.capacity)
+                error = I18n.t('.active_bookings.availability.already_booked', model: self.class.to_s)
+                raise ActiveBookings::AvailabilityError.new error
+              end
+
+              res
+            end
+          # else, just sum the amounts (fixed times are not intervals and they overlap if are the same)
+          else
+            if(overlapped.sum(:amount) + opts[:amount] > self.capacity)
+              error = I18n.t('.active_bookings.availability.already_booked', model: self.class.to_s)
+              raise ActiveBookings::AvailabilityError.new error
+            end
+          end
+        end
+        true
+      end
+
+      ##
+      # Check availability of current bookable
+      #
+      # @param opts The booking options
+      # @return true if the bookable is available for given options, otherwise return false
+      #
+      # Example:
+      #   @room.check_availability!(from: Date.today, to: Date.tomorrow, amount: 2)
+      def check_availability(opts)
+        begin
+          check_availability!(opts)
+        rescue ActiveBookings::AvailabilityError
+          false
+        end
+      end
+
+      ##
+      # Accept a booking by a booker. This is an alias method,
+      # equivalent to @booker.book!(@bookable, opts)
+      #
+      # @param booker The booker model
+      # @param opts The booking options
+      #
+      # Example:
+      #   @room.book!(@user, from: Date.today, to: Date.tomorrow, amount: 2)
+      def book!(booker, opts={})
+        booker.book!(self, opts)
+      end
+
+      ##
+      # Check if options passed for booking this Bookable are valid
+      #
+      # @raise ActiveBookings::OptionsInvalid if options are not valid
+      # @param opts The booking options
+      #
+      def validate_booking_options!(opts)
+        self.class.validate_booking_options!(opts)
+      end
+
+      def booker?
+        self.class.booker?
+      end
+    end
+  end
+end

data/lib/active_bookings/booker.rb

@@ -0,0 +1,68 @@
+module ActiveBookings
+  module Booker
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      ##
+      # Make a model a booker. This allows an instance of a model to claim ownership
+      # of bookings.
+      #
+      # Example:
+      #   class User < ActiveRecord::Base
+      #     is_booker
+      #   end
+      def is_booker(opts={})
+        class_eval do
+          has_many :bookings, as: :booker, dependent: :destroy, class_name: '::ActiveBookings::Booking'
+        end
+
+        include ActiveBookings::Booker::InstanceMethods
+        extend ActiveBookings::Booker::SingletonMethods
+      end
+
+      def booker?
+        false
+      end
+    end
+
+    module InstanceMethods
+      ##
+      # Book a bookable model
+      #
+      # @param bookable The resource that will be booked
+      # @return The booking created
+      # @raise ActiveBookings::OptionsInvalid if opts are not valid for given bookable
+      # @raise ActiveBookings::AvailabilityError if the bookable is not available for given options
+      # @raise ActiveRecord::RecordInvalid if trying to create an invalid booking
+      #
+      # Example:
+      #   @user.book!(@room)
+      def book!(bookable, opts={})
+        # check availability
+        bookable.check_availability!(opts) if bookable.class.bookable?
+
+        # create the new booking
+        booking_params = opts.merge({booker: self, bookable: bookable})
+        booking_class = bookable.class.reflect_on_association(:bookings).klass
+        booking = booking_class.create!(booking_params)
+
+        # reload the bookable to make changes available
+        bookable.reload
+        self.reload
+        booking
+      end
+
+      def booker?
+        self.class.booker?
+      end
+    end
+
+    module SingletonMethods
+      def booker?
+        true
+      end
+    end
+  end
+end

data/lib/active_bookings/booking.rb

@@ -0,0 +1,41 @@
+module ActiveBookings
+  # Booking model. Store in database bookings made by bookers on bookables
+  class Booking < ::ActiveRecord::Base
+    self.table_name = 'bookings'
+
+    belongs_to :bookable, polymorphic: true
+    belongs_to :booker,   polymorphic: true
+
+    validates_presence_of :bookable
+    validates_presence_of :booker
+
+    validate :bookable_must_be_bookable, :booker_must_be_booker
+
+    # Retrieves overlapped bookings, given a bookable and some booking options
+    scope :overlapped, -> (bookable,opts) {
+      query = where(bookable_id: bookable.id)
+
+      # Time options
+      query = DBUtils.time_comparison(query, 'time','=', opts[:time]) if opts[:time].present?
+      query = DBUtils.time_comparison(query, 'time_end', '>=', opts[:time_start]) if opts[:time_start].present?
+      query = DBUtils.time_comparison(query, 'time_start', '<', opts[:time_end]) if opts[:time_end].present?
+
+      query
+    }
+
+    private
+      # Validation method. Check if the bookable resource is actually bookable
+      def bookable_must_be_bookable
+        if bookable.present? && !bookable.class.bookable?
+          errors.add(:bookable, T.er('booking.bookable_must_be_bookable', model: bookable.class.to_s))
+        end
+      end
+
+      # Validation method. Check if the booker model is actually a booker
+      def booker_must_be_booker
+        if booker.present? && !booker.class.booker?
+          errors.add(:booker, T.er('booking.booker_must_be_booker', model: booker.class.to_s))
+        end
+      end
+  end
+end

data/lib/active_bookings/db_utils.rb

@@ -0,0 +1,50 @@
+module ActiveBookings
+  module DBUtils
+    class << self
+      def connection
+        ActiveBookings::Booking.connection
+      end
+
+      def using_postgresql?
+        connection && connection.adapter_name == 'PostgreSQL'
+      end
+
+      def using_mysql?
+        #We should probably use regex for mysql to support prehistoric adapters
+        connection && connection.adapter_name == 'Mysql2'
+      end
+
+      def using_sqlite?
+        connection && connection.adapter_name == 'SQLite'
+      end
+
+      def active_record4?
+        ::ActiveRecord::VERSION::MAJOR == 4
+      end
+
+      def active_record5?
+        ::ActiveRecord::VERSION::MAJOR == 5
+      end
+
+      def like_operator
+        using_postgresql? ? 'ILIKE' : 'LIKE'
+      end
+
+      # Compare times according to the DB
+      def time_comparison(query, field, operator, time)
+        if using_postgresql?
+          query.where("#{field}::timestamp #{operator} ?::timestamp", time.to_time.utc.to_s)
+        elsif using_sqlite?
+          query.where("Datetime(#{field}) #{operator} Datetime('#{time.to_time.utc.iso8601}')")
+        else
+          query.where("#{field} #{operator} ?", time.to_time)
+        end
+      end
+
+      # escape _ and % characters in strings, since these are wildcards in SQL.
+      def escape_like(str)
+        str.gsub(/[!%_]/) { |x| '!' + x }
+      end
+    end
+  end
+end

data/lib/active_bookings/serializer.rb

@@ -0,0 +1,17 @@
+module ActiveBookings
+  module Serializer
+    class << self
+      def load(string)
+        if string.present?
+          IceCube::Schedule.from_yaml(string)
+        end
+      end
+
+      def dump(object)
+        if object.is_a? IceCube::Schedule
+          object.to_yaml
+        end
+      end
+    end
+  end
+end

data/lib/active_bookings/time_utils.rb

@@ -0,0 +1,135 @@
+module ActiveBookings
+  ##
+  # 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, { spans: 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/active_bookings/version.rb

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

data/lib/generators/active_bookings/install_generator.rb

@@ -0,0 +1,28 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+require 'rails/generators/active_record'
+
+module ActiveBookings
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    desc 'Generates migrations to add Active Bookings table.'
+    source_root File.expand_path('../templates', __FILE__)
+
+    def create_migration_file
+      migration_template 'migration/migration.rb', 'db/migrate/create_active_bookings.rb'
+    end
+
+    def create_model_file
+      template 'model/booking.rb', 'app/models/booking.rb'
+    end
+
+    def create_locale_file
+      template 'locale/en.yml', 'config/locales/active_bookings.en.yml'
+    end
+
+    def self.next_migration_number(dirname)
+      ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+  end
+end

data/lib/generators/active_bookings/templates/locale/en.yml

@@ -0,0 +1,10 @@
+en:
+  active_bookings:
+    booking:
+      bookable_must_be_bookable: "cannot book a %{model} as it is not bookable"
+      booker_must_be_booker: "a %{model} cannot book a resource, because %{model} is not a booker"
+    availability:
+      amount_gt_capacity: "amount cannot be greater than %{model} capacity"
+      already_booked: "the %{model} is fully booked"
+      unavailable_interval: "the %{model} is not available from %{time_start} to %{time_end}"
+      unavailable_time: "the %{model} is not available at %{time}"

data/lib/generators/active_bookings/templates/migration/migration.rb

@@ -0,0 +1,15 @@
+class CreateActiveBookings < ActiveRecord::Migration[5.0]
+  def change
+    create_table :bookings do |t|
+      t.references :bookable, polymorphic: true, index: { name: 'index_active_bookings_bookable' }
+      t.references :booker, polymorphic: true, index: { name: 'index_active_bookings_booker' }
+      t.column :amount, :integer
+      t.column :schedule, :text
+      t.column :time_start, :datetime
+      t.column :time_end, :datetime
+      t.column :time, :datetime
+
+      t.timestamps
+    end
+  end
+end

data/lib/generators/active_bookings/templates/model/booking.rb

@@ -0,0 +1,2 @@
+class Booking < ActiveBookings::Booking
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: active_bookings
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jonian Guveli
+- Olibia Tsati
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-05-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: ice_cube
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Make ActiveRecord models bookable with availability rules, schedule etc.
+email:
+- info@hardpixel.eu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/active_bookings.rb
+- lib/active_bookings/bookable.rb
+- lib/active_bookings/bookable/core.rb
+- lib/active_bookings/booker.rb
+- lib/active_bookings/booking.rb
+- lib/active_bookings/db_utils.rb
+- lib/active_bookings/serializer.rb
+- lib/active_bookings/time_utils.rb
+- lib/active_bookings/version.rb
+- lib/generators/active_bookings/install_generator.rb
+- lib/generators/active_bookings/templates/locale/en.yml
+- lib/generators/active_bookings/templates/migration/migration.rb
+- lib/generators/active_bookings/templates/model/booking.rb
+homepage: https://github.com/hardpixel/active-bookings
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Rails reservation engine that allows bookable resources
+test_files: []