mongoid_occurrences 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b3eb3d953d69a2671b169b5871a250971b33c948b5d0d9d6a9ada698eb7bfed7
+  data.tar.gz: 0317f7a065c2dabbed6a4febd03e5920850d3b554044d3e2cc04fdf406c69987
+SHA512:
+  metadata.gz: 506b446a5afc98f7308d89b4e64fb756c3ce3264243a6620daebd5f1e92d2df85c3d9ae3de0255529d623ebe7340be7e99fbffbe197d635299545015daaec0a5
+  data.tar.gz: 61ee2fe086a87f5e7f57e4edf7f34032a9fa62e75f94fd642b78201ded701870aab0c4d38590f384ab6a0eecaed8befff2f0e6f84bbabd7f3cb81b5d4af5c0f4

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,19 @@
+language: ruby
+cache: bundler
+script: 'bundle exec rake'
+rvm:
+  - 2.5.1
+services:
+  - mongodb
+
+notifications:
+  email:
+    recipients:
+      - tomas.celizna@gmail.com
+    on_failure: change
+    on_success: never
+
+matrix:
+  include:
+    - rvm: 2.5.1
+      env: MONGOID_VERSION=7

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# CHANGELOG
+
+## 1.0.0
+
+* [PR#4](https://github.com/tomasc/mongoid_occurrences/pull/4) Refactor to replace views with aggregations
+
+## 0.2.0
+
+* [PR#3](https://github.com/tomasc/mongoid_occurrences/pull/3) `all_day` becomes a field
+
+## 0.1.1
+
+* [PR#2](https://github.com/tomasc/mongoid_occurrences/pull/2) allow :assign_daily_occurrences to be triggerred manually
+
+## 0.1.0
+
+* initial release

data/Gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in mongoid_occurrences.gemspec
+gemspec
+
+case version = ENV['MONGOID_VERSION'] || '~> 7.0'
+when /7/ then gem 'mongoid', '~> 7.0'
+else gem 'mongoid', version
+end

data/Guardfile

@@ -0,0 +1,5 @@
+guard :minitest do
+  watch(%r{^lib/(.+)\.rb$})                               { |m| "test/#{m[1]}_test.rb" }
+  watch(%r{^test/.+_test\.rb$})
+  watch(%r{^test/test_helper\.rb$})                       { 'test' }
+end

data/README.md

@@ -0,0 +1,147 @@
+# Mongoid Occurrences
+
+[![Build Status](https://travis-ci.org/tomasc/mongoid_occurrences.svg)](https://travis-ci.org/tomasc/mongoid_occurrences) [![Gem Version](https://badge.fury.io/rb/mongoid_occurrences.svg)](http://badge.fury.io/rb/mongoid_occurrences) [![Coverage Status](https://img.shields.io/coveralls/tomasc/mongoid_occurrences.svg)](https://coveralls.io/r/tomasc/mongoid_occurrences)
+
+Facilitates aggregations for events with multiple occurrences or a recurring schedule.
+
+## Requirements
+
+* Mongoid 7+
+* MongoDB 3.4+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mongoid_occurrences'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mongoid_occurrences
+
+## Usage
+
+### Event
+
+Define a Mongoid document that will embed occurrence definitions.
+
+```ruby
+class Event
+  include Mongoid::Document
+  include MongoidOccurrences::HasOccurrences
+
+  embeds_many_occurrences class_name: "Occurrence"
+end
+```
+
+This document will gain the `#assign_daily_occurrences!` method (automatically triggered `:after_validation`), which expands all occurrence definitions in the embedded relation called `#daily_occurrences`.
+
+The class will also gain the following scopes, useful for querying for events based on the `#daily_occurrences`:
+
+* `.occurs_between(dtstart, dtend)`
+* `.occurs_from(dtstart)`
+* `.occurs_on(day)`
+* `.occurs_until(dtend)`
+
+### Occurrence
+
+Define a Mongoid document that defines the occurrence.
+
+```ruby
+class Occurrence
+  include Mongoid::Document
+  include MongoidOccurrences::Occurrence
+
+  embedded_in_event class_name: 'Event'
+end
+```
+
+This document will gain the `#dtstart`, `#dtend` and `#all_day` fields to define individual occurrences.
+
+Recurring schedule is handled via the [IceCube](https://github.com/seejohnrun/ice_cube) and [MongoidIceCubeExtension](https://github.com/tomasc/mongoid_ice_cube_extension) gems. The model gains `#schedule`, and `#schedule_dtstart`, `#schedule_dtend` fields (with default values for schedule 1 year from now), along with `#recurrence_rule=` writer method.
+
+It is possible to influence the way the occurrences are expanded into `#daily_occurrences` using the `#operator` enum field, which accepts the following values:
+
+* `:append` – appends to the list of `#daily_occurrences` (default)
+* `:replace` – replaces all occurrences that happen on the same day with itself
+* `:remove` - removes all occurrences that happen on the same day
+
+### Indexes
+
+To optimize the performance of the above scope queries, you might want to add the following indexes:
+
+```ruby
+index :'daily_occurrences.ds' => 1
+index :'daily_occurrences.de' => 1
+```
+
+### Aggregations
+
+It is possible to aggregate (unwind) the events so that they are multiplied per daily occurrences. Example aggregations are included:
+
+* `MongoidOccurrences::Aggregations::OccursBetween.instantiate(Event.criteria, dtstart, dtend)`
+* `MongoidOccurrences::Aggregations::OccursFrom.instantiate(Event.criteria, dtstart)`
+* `MongoidOccurrences::Aggregations::OccursOn.instantiate(Event.criteria, day)`
+* `MongoidOccurrences::Aggregations::OccursUntil.instantiate(Event.criteria, dtend)`
+
+The aggregations will add `#_dtstart`, `#_dtend` fields to the unwound documents. For easier access, mixin the `MongoidOccurrences::HasFieldsFromAggregation` to your `Event` class:
+
+```ruby
+class Event
+  include Mongoid::Document
+  include MongoidOccurrences::HasFieldsFromAggregation
+  include MongoidOccurrences::HasOccurrences
+
+  embeds_many_occurrences class_name: "Occurrence"
+end
+```
+
+This will automatically add `#dtstart` and `#dtend` fields with correct (demongoized) values, as well as the `#all_day?` method.
+
+### Embedded events
+
+If your events are itself embedded:
+
+```ruby
+class EventParent
+  embeds_many :events, class_name: 'Event'
+end
+```
+
+Simply add the following scopes on the parent document:
+
+```ruby
+class EventParent
+  scope :occurs_between, ->(dtstart, dtend) { elem_match(events: Event.occurs_between(dtstart, dtend).selector) }
+  scope :occurs_from, ->(date_time) { elem_match(events: Event.occurs_from(date_time).selector) }
+  scope :occurs_on, ->(date_time) { elem_match(events: Event.occurs_on(date_time).selector) }
+  scope :occurs_until, ->(date_time) { elem_match(events: Event.occurs_until(date_time).selector) }
+end
+```
+
+You will then need to write your own aggregations with an extra step to `$unwind` the embedded `#events`, and your indexes will need to be adjusted as follows:
+
+```ruby
+index :'events.daily_occurrences.ds' => 1
+index :'events.daily_occurrences.de' => 1
+```
+
+## 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`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/tomasc/mongoid_occurrences.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mongoid_occurrences"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mongoid_occurrences/aggregations/aggregation.rb

@@ -0,0 +1,51 @@
+module MongoidOccurrences
+  module Aggregations
+    class Aggregation
+      def self.option(name, default_value=nil)
+        define_method(name) do
+          HashWithIndifferentAccess[options].fetch(name, default_value)
+        end
+      end
+
+      def self.instantiate(*args)
+        new(*args).instantiate
+      end
+
+      option :allow_disk_use, true
+      option :sort_key, :_dtstart
+      option :sort_order, :asc
+
+      def initialize(base_criteria, options = {})
+        @base_criteria = base_criteria
+        @options = options
+      end
+
+      def aggregation
+        base_criteria.klass
+                     .collection
+                     .aggregate(
+                       (selectors + pipeline),
+                       allow_disk_use: allow_disk_use
+                     )
+      end
+
+      def instantiate
+        aggregation.map do |doc|
+          base_criteria.klass.instantiate(doc)
+        end
+      end
+
+      private
+
+      def selectors
+        [
+          { '$match' => { '$and' => [criteria.selector] } },
+          { '$sort' => criteria.options[:sort] },
+          { '$limit' => criteria.options[:limit] }
+        ].map { |i| i.delete_if { |_, v| v.blank? } }.reject(&:blank?)
+      end
+
+      attr_reader :base_criteria, :options
+    end
+  end
+end

data/lib/mongoid_occurrences/aggregations/occurs_between.rb

@@ -0,0 +1,33 @@
+require 'mongoid_occurrences/aggregations/aggregation'
+
+module MongoidOccurrences
+  module Aggregations
+    class OccursBetween < Aggregation
+      def initialize(base_criteria, dtstart, dtend, options = {})
+        @base_criteria = base_criteria
+        @dtstart = dtstart
+        @dtend = dtend
+        @options = options
+      end
+
+      private
+
+      def criteria
+        base_criteria.occurs_between(dtstart, dtend)
+      end
+
+      def pipeline
+        [
+          { '$addFields' => { '_daily_occurrences' => '$daily_occurrences' } },
+          { '$unwind' => { 'path' => '$_daily_occurrences' } },
+          { '$addFields' => { '_dtstart' => '$_daily_occurrences.ds', '_dtend' => '$_daily_occurrences.de' } },
+          { '$project' => { '_daily_occurrences' => 0 } },
+          { '$match' => Queries::OccursBetween.criteria(base_criteria, dtstart, dtend, dtstart_field: '_dtstart', dtend_field: '_dtend').selector },
+          { '$sort' => { sort_key => { asc: 1, desc: -1 }[sort_order] } }
+        ]
+      end
+
+      attr_reader :dtstart, :dtend, :options
+    end
+  end
+end

data/lib/mongoid_occurrences/aggregations/occurs_from.rb

@@ -0,0 +1,32 @@
+require 'mongoid_occurrences/aggregations/aggregation'
+
+module MongoidOccurrences
+  module Aggregations
+    class OccursFrom < Aggregation
+      def initialize(base_criteria, date_time, options = {})
+        @base_criteria = base_criteria
+        @date_time = date_time
+        @options = options
+      end
+
+      private
+
+      def criteria
+        base_criteria.occurs_from(date_time)
+      end
+
+      def pipeline
+        [
+          { '$addFields' => { '_daily_occurrences' => '$daily_occurrences' } },
+          { '$unwind' => { 'path' => '$_daily_occurrences' } },
+          { '$addFields' => { '_dtstart' => '$_daily_occurrences.ds', '_dtend' => '$_daily_occurrences.de' } },
+          { '$project' => { '_daily_occurrences' => 0 } },
+          { '$match' => Queries::OccursFrom.criteria(base_criteria, date_time, dtstart_field: '_dtstart').selector },
+          { '$sort' => { sort_key => { asc: 1, desc: -1 }[sort_order] } }
+        ]
+      end
+
+      attr_reader :date_time, :options
+    end
+  end
+end

data/lib/mongoid_occurrences/aggregations/occurs_on.rb

@@ -0,0 +1,32 @@
+require 'mongoid_occurrences/aggregations/aggregation'
+
+module MongoidOccurrences
+  module Aggregations
+    class OccursOn < Aggregation
+      def initialize(base_criteria, date_time, options = {})
+        @base_criteria = base_criteria
+        @date_time = date_time
+        @options = options
+      end
+
+      private
+
+      def criteria
+        base_criteria.occurs_on(date_time)
+      end
+
+      def pipeline
+        [
+          { '$addFields' => { '_daily_occurrences' => '$daily_occurrences' } },
+          { '$unwind' => { 'path' => '$_daily_occurrences' } },
+          { '$addFields' => { '_dtstart' => '$_daily_occurrences.ds', '_dtend' => '$_daily_occurrences.de' } },
+          { '$project' => { '_daily_occurrences' => 0 } },
+          { '$match' => Queries::OccursOn.criteria(base_criteria, date_time, dtstart_field: '_dtstart', dtend_field: '_dtend').selector },
+          { '$sort' => { sort_key => { asc: 1, desc: -1 }[sort_order] } }
+        ]
+      end
+
+      attr_reader :date_time, :options
+    end
+  end
+end

data/lib/mongoid_occurrences/aggregations/occurs_until.rb

@@ -0,0 +1,32 @@
+require 'mongoid_occurrences/aggregations/aggregation'
+
+module MongoidOccurrences
+  module Aggregations
+    class OccursUntil < Aggregation
+      def initialize(base_criteria, date_time, options = {})
+        @base_criteria = base_criteria
+        @date_time = date_time
+        @options = options
+      end
+
+      private
+
+      def criteria
+        base_criteria.occurs_until(date_time)
+      end
+
+      def pipeline
+        [
+          { '$addFields' => { '_daily_occurrences' => '$daily_occurrences' } },
+          { '$unwind' => { 'path' => '$_daily_occurrences' } },
+          { '$addFields' => { '_dtstart' => '$_daily_occurrences.ds', '_dtend' => '$_daily_occurrences.de' } },
+          { '$project' => { '_daily_occurrences' => 0 } },
+          { '$match' => Queries::OccursUntil.criteria(base_criteria, date_time, dtend_field: '_dtend').selector },
+          { '$sort' => { sort_key => { asc: 1, desc: -1 }[sort_order] } }
+        ]
+      end
+
+      attr_reader :date_time, :options
+    end
+  end
+end

data/lib/mongoid_occurrences/daily_occurrence/has_scopes.rb

@@ -0,0 +1,12 @@
+module MongoidOccurrences
+  class DailyOccurrence
+    module HasScopes
+      def self.included(base)
+        base.scope :occurs_between, ->(dtstart, dtend) { Queries::OccursBetween.criteria(criteria, dtstart, dtend) }
+        base.scope :occurs_from, ->(dtstart) { Queries::OccursFrom.criteria(criteria, dtstart) }
+        base.scope :occurs_on, ->(day) { Queries::OccursOn.criteria(criteria, day) }
+        base.scope :occurs_until, ->(dtend) { Queries::OccursUntil.criteria(criteria, dtend) }
+      end
+    end
+  end
+end

data/lib/mongoid_occurrences/daily_occurrence.rb

@@ -0,0 +1,42 @@
+require 'mongoid_occurrences/daily_occurrence/has_scopes'
+
+module MongoidOccurrences
+  class DailyOccurrence
+    include Mongoid::Document
+    include HasScopes
+
+    attr_accessor :operator
+
+    field :ds, as: :dtstart, type: DateTime
+    field :de, as: :dtend, type: DateTime
+
+    validates :dtstart, presence: true
+    validates :dtend, presence: true
+
+    def operator
+      @operator ||= :append
+    end
+
+    def all_day
+      dtstart.to_i == dtstart.beginning_of_day.to_i &&
+        dtend.to_i == dtend.end_of_day.to_i
+    end
+    alias all_day? all_day
+
+    def <=>(other)
+      sort_key <=> other.sort_key
+    end
+
+    def sort_key
+      [dtstart, dtend]
+    end
+
+    def to_range
+      (dtstart..dtend)
+    end
+
+    def overlaps?(occurrence)
+      to_range.overlaps?(occurrence.to_range)
+    end
+  end
+end

data/lib/mongoid_occurrences/has_fields_from_aggregation.rb

@@ -0,0 +1,25 @@
+module MongoidOccurrences
+  module HasFieldsFromAggregation
+    def dtstart
+      @dtstart ||= DateTime.demongoize(
+        self['_dtstart'] ||
+          daily_occurrences.unscoped.order(dtstart: :asc).limit(1).pluck(:dtstart).first
+      )
+    end
+
+    def dtend
+      @dtend ||= DateTime.demongoize(
+        self['_dtend'] ||
+          daily_occurrences.unscoped.order(dtend: :desc).limit(1).pluck(:dtend).first
+      )
+    end
+
+    def all_day
+      return unless dtstart && dtend
+
+      dtstart.to_i == dtstart.beginning_of_day.to_i &&
+        dtend.to_i == dtend.end_of_day.to_i
+    end
+    alias all_day? all_day
+  end
+end

data/lib/mongoid_occurrences/has_occurrences.rb

@@ -0,0 +1,51 @@
+module MongoidOccurrences
+  module HasOccurrences
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def embeds_many_occurrences(options = {})
+        field :_previous_occurences_cache_key, type: String
+
+        embeds_many :occurrences, class_name: options.fetch(:class_name)
+        accepts_nested_attributes_for :occurrences, allow_destroy: true, reject_if: :all_blank
+
+        embeds_many :daily_occurrences, class_name: 'MongoidOccurrences::DailyOccurrence', order: :dtstart.asc
+
+        after_validation :assign_occurrences_cache_key!
+        after_validation :assign_daily_occurrences!, if: :_previous_occurences_cache_key_changed?
+
+        scope :occurs_between, ->(dtstart, dtend) { elem_match(daily_occurrences: DailyOccurrence.occurs_between(dtstart, dtend).selector) }
+        scope :occurs_from, ->(dtstart) { elem_match(daily_occurrences: DailyOccurrence.occurs_from(dtstart).selector) }
+        scope :occurs_on, ->(day) { elem_match(daily_occurrences: DailyOccurrence.occurs_on(day).selector) }
+        scope :occurs_until, ->(dtend) { elem_match(daily_occurrences: DailyOccurrence.occurs_until(dtend).selector) }
+      end
+    end
+
+    def occurences_cache_key
+      last_timestamp = occurrences.unscoped.order(updated_at: :desc).limit(1).pluck(:updated_at).first
+      "#{occurrences.unscoped.size}-#{last_timestamp.to_i}"
+    end
+
+    def assign_daily_occurrences!
+      self.daily_occurrences = begin
+        res = occurrences.with_operators(:append).flat_map(&:daily_occurrences)
+
+        occurrences.with_operators(%i[remove replace]).flat_map(&:daily_occurrences).each do |occurrence|
+          res = res.reject { |res_occurrence| res_occurrence.overlaps?(occurrence) }
+        end
+
+        res += occurrences.with_operators(%i[replace]).flat_map(&:daily_occurrences)
+
+        res.sort
+      end
+    end
+
+    private
+
+    def assign_occurrences_cache_key!
+      self._previous_occurences_cache_key = occurences_cache_key
+    end
+  end
+end

data/lib/mongoid_occurrences/occurrence/has_daily_occurrences.rb

@@ -0,0 +1,46 @@
+module MongoidOccurrences
+  module Occurrence
+    module HasDailyOccurrences
+      def daily_occurrences
+        adjust_dates_for_all_day!
+
+        daily_occurrences_from_schedule +
+          daily_occurrences_from_date_range
+      end
+
+      private
+
+      def daily_occurrences_from_schedule
+        return [] unless dtstart? && dtend?
+        return [] unless recurring?
+
+        schedule.occurrences(schedule_dtend).map do |occurrence|
+          MongoidOccurrences::DailyOccurrence.new(
+            dtstart: occurrence.start_time.change(hour: dtstart.hour, min: dtstart.minute),
+            dtend: occurrence.end_time.change(hour: dtend.hour, min: dtend.minute),
+            operator: operator
+          )
+        end
+      end
+
+      def daily_occurrences_from_date_range
+        return [] unless dtstart? && dtend?
+        return [] if recurring?
+
+        date_range = Range.new(dtstart.to_date, dtend.to_date)
+        is_single_day = (date_range.first == date_range.last)
+
+        date_range.map do |date|
+          occurence_dtstart = is_single_day || date == date_range.first ? dtstart : date.beginning_of_day
+          occurence_dtend = is_single_day || date == date_range.last ? dtend : date.end_of_day
+
+          MongoidOccurrences::DailyOccurrence.new(
+            dtstart: occurence_dtstart,
+            dtend: occurence_dtend,
+            operator: operator
+          )
+        end
+      end
+    end
+  end
+end

data/lib/mongoid_occurrences/occurrence/has_operators.rb

@@ -0,0 +1,20 @@
+require 'mongoid/enum_attribute'
+
+module MongoidOccurrences
+  module Occurrence
+    module HasOperators
+      def self.prepended(base)
+        base.scope :with_operators, ->(operators) { criteria.in(_operator: Array(operators)) }
+      end
+
+      module ClassMethods
+        def embedded_in_event(options = {})
+          super(options)
+
+          include Mongoid::EnumAttribute
+          enum :operator, %i[append replace remove], default: :append
+        end
+      end
+    end
+  end
+end

data/lib/mongoid_occurrences/occurrence/has_schedule.rb

@@ -0,0 +1,54 @@
+module MongoidOccurrences
+  module Occurrence
+    module HasSchedule
+      SCHEDULE_DURATION = 1.year
+
+      module ClassMethods
+        def embedded_in_event(options = {})
+          super(options)
+
+          field :schedule, type: MongoidIceCubeExtension::Schedule
+          field :schedule_dtstart, type: Time
+          field :schedule_dtend, type: Time
+
+          before_validation :nil_schedule, unless: :recurring?
+        end
+      end
+
+      def schedule_dtstart
+        read_attribute(:schedule_dtstart) ||
+          (dtstart.try(:to_time) || Time.now)
+      end
+
+      def schedule_dtend
+        read_attribute(:schedule_dtend) ||
+          (schedule_dtstart + SCHEDULE_DURATION)
+      end
+
+      def recurrence_rule
+        schedule&.recurrence_rules&.first
+      end
+
+      def recurrence_rule=(value)
+        case value
+        when NilClass, 'null'
+          @recurrence_rule = nil
+          self.schedule = nil
+        else
+          @recurrence_rule = IceCube::Rule.from_hash(JSON.parse(value))
+          self.schedule = IceCube::Schedule.new(schedule_dtstart) { |s| s.add_recurrence_rule(@recurrence_rule) }
+        end
+      end
+
+      def recurring?
+        schedule.present?
+      end
+
+      private
+
+      def nil_schedule
+        self.schedule = nil
+      end
+    end
+  end
+end

data/lib/mongoid_occurrences/occurrence.rb

@@ -0,0 +1,53 @@
+require 'mongoid_occurrences/occurrence/has_daily_occurrences'
+require 'mongoid_occurrences/occurrence/has_operators'
+require 'mongoid_occurrences/occurrence/has_schedule'
+
+module MongoidOccurrences
+  module Occurrence
+    def self.included(base)
+      base.extend ClassMethods
+
+      base.include Mongoid::Timestamps::Updated
+
+      base.include HasDailyOccurrences
+
+      base.prepend HasOperators
+      base.singleton_class.prepend HasOperators::ClassMethods
+
+      base.prepend HasSchedule
+      base.singleton_class.prepend HasSchedule::ClassMethods
+    end
+
+    module ClassMethods
+      def embedded_in_event(options = {})
+        field :dtstart, type: DateTime
+        field :dtend, type: DateTime
+        field :all_day, type: Boolean
+
+        embedded_in :event, class_name: options.fetch(:class_name, nil), inverse_of: :occurrences
+
+        after_validation :adjust_dates_for_all_day!, if: :changed?
+
+        validates :dtstart, presence: true
+        validates :dtend, presence: true
+      end
+    end
+
+    def all_day
+      return super unless dtstart.present? && dtend.present?
+      return super unless super.nil?
+
+      dtstart.to_i == dtstart.beginning_of_day.to_i &&
+        dtend.to_i == dtend.end_of_day.to_i
+    end
+    alias all_day? all_day
+
+    def adjust_dates_for_all_day!
+      return unless all_day?
+      return unless dtstart? && dtend?
+
+      self.dtstart = dtstart.beginning_of_day
+      self.dtend = dtend.end_of_day
+    end
+  end
+end

data/lib/mongoid_occurrences/queries/occurs_between.rb

@@ -0,0 +1,34 @@
+require 'mongoid_occurrences/queries/query'
+
+module MongoidOccurrences
+  module Queries
+    class OccursBetween < Query
+      option :dtstart_field, :dtstart
+      option :dtend_field, :dtend
+
+      def initialize(base_criteria, dtstart, dtend, options = {})
+        @base_criteria = base_criteria
+        @dtstart = dtstart
+        @dtend = dtend
+        @options = options
+      end
+
+      def criteria
+        base_criteria.lte(dtstart_field => adjusted_dtend)
+                     .gte(dtend_field => adjusted_dtstart)
+      end
+
+      private
+
+      def adjusted_dtstart
+        dtstart.instance_of?(Date) ? dtstart.beginning_of_day : dtstart
+      end
+
+      def adjusted_dtend
+        dtend.instance_of?(Date) ? dtend.beginning_of_day : dtend
+      end
+
+      attr_reader :dtstart, :dtend, :options
+    end
+  end
+end

data/lib/mongoid_occurrences/queries/occurs_from.rb

@@ -0,0 +1,27 @@
+require 'mongoid_occurrences/queries/query'
+
+module MongoidOccurrences
+  module Queries
+    class OccursFrom < Query
+      option :dtstart_field, :dtstart
+
+      def initialize(base_criteria, date_time, options = {})
+        @base_criteria = base_criteria
+        @date_time = date_time
+        @options = options
+      end
+
+      def criteria
+        base_criteria.gte(dtstart_field => adjusted_date_time)
+      end
+
+      private
+
+      def adjusted_date_time
+        date_time.instance_of?(Date) ? date_time.beginning_of_day : date_time
+      end
+
+      attr_reader :date_time, :options
+    end
+  end
+end

data/lib/mongoid_occurrences/queries/occurs_on.rb

@@ -0,0 +1,29 @@
+require 'mongoid_occurrences/queries/query'
+
+module MongoidOccurrences
+  module Queries
+    class OccursOn < Query
+      def initialize(base_criteria, date_time, options = {})
+        @base_criteria = base_criteria
+        @date_time = date_time
+        @options = options
+      end
+
+      def criteria
+        OccursBetween.criteria(base_criteria, adjusted_dtstart, adjusted_dtend, options)
+      end
+
+      private
+
+      def adjusted_dtstart
+        date_time.instance_of?(Date) ? date_time.beginning_of_day : date_time
+      end
+
+      def adjusted_dtend
+        date_time.instance_of?(Date) ? date_time.end_of_day : date_time
+      end
+
+      attr_reader :date_time, :options
+    end
+  end
+end

data/lib/mongoid_occurrences/queries/occurs_until.rb

@@ -0,0 +1,27 @@
+require 'mongoid_occurrences/queries/query'
+
+module MongoidOccurrences
+  module Queries
+    class OccursUntil < Query
+      option :dtend_field, :dtend
+
+      def initialize(base_criteria, date_time, options = {})
+        @base_criteria = base_criteria
+        @date_time = date_time
+        @options = options
+      end
+
+      def criteria
+        base_criteria.lte(dtend_field => adjusted_date_time)
+      end
+
+      private
+
+      def adjusted_date_time
+        date_time.instance_of?(Date) ? date_time.end_of_day : date_time
+      end
+
+      attr_reader :date_time, :options
+    end
+  end
+end

data/lib/mongoid_occurrences/queries/query.rb

@@ -0,0 +1,27 @@
+module MongoidOccurrences
+  module Queries
+    class Query
+      def initialize(base_criteria)
+        @base_criteria = base_criteria
+      end
+
+      def self.criteria(*args)
+        new(*args).criteria
+      end
+
+      def self.option(name, default_value=nil)
+        define_method(name) do
+          HashWithIndifferentAccess[options].fetch(name, default_value)
+        end
+      end
+
+      def criteria
+        raise NotImplementedError
+      end
+
+      private
+
+      attr_reader :base_criteria
+    end
+  end
+end

data/lib/mongoid_occurrences/version.rb

@@ -0,0 +1,3 @@
+module MongoidOccurrences
+  VERSION = '1.0.0'.freeze
+end

data/lib/mongoid_occurrences.rb

@@ -0,0 +1,19 @@
+require 'mongoid_occurrences/version'
+
+require 'mongoid'
+require 'mongoid_ice_cube_extension'
+
+require 'mongoid_occurrences/daily_occurrence'
+require 'mongoid_occurrences/has_fields_from_aggregation'
+require 'mongoid_occurrences/has_occurrences'
+require 'mongoid_occurrences/occurrence'
+
+require 'mongoid_occurrences/aggregations/occurs_between'
+require 'mongoid_occurrences/aggregations/occurs_from'
+require 'mongoid_occurrences/aggregations/occurs_on'
+require 'mongoid_occurrences/aggregations/occurs_until'
+
+require 'mongoid_occurrences/queries/occurs_between'
+require 'mongoid_occurrences/queries/occurs_from'
+require 'mongoid_occurrences/queries/occurs_on'
+require 'mongoid_occurrences/queries/occurs_until'

data/mongoid_occurrences.gemspec

@@ -0,0 +1,37 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongoid_occurrences/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mongoid_occurrences'
+  spec.version       = MongoidOccurrences::VERSION
+  spec.authors       = ['Tomas Celizna', 'Asger Behncke Jacobsen']
+  spec.email         = ['tomas.celizna@gmail.com', 'a@asgerbehnckejacobsen.dk']
+
+  spec.summary       = 'Facilitates aggregations for events with multiple occurrences or a recurring schedule.'
+  spec.homepage      = 'https://github.com/tomasc/mongoid_occurrences'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'ice_cube'
+  spec.add_dependency 'mongoid', '>= 7.0.2', '< 8'
+  spec.add_dependency 'mongoid-enum_attribute'
+  spec.add_dependency 'mongoid_ice_cube_extension', '>= 0.1.1'
+
+  spec.add_development_dependency 'activesupport', '> 3.0'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'database_cleaner'
+  spec.add_development_dependency 'factory_bot', '~> 4.0'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-minitest'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'minitest-implicit-subject'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

metadata

@@ -0,0 +1,278 @@
+--- !ruby/object:Gem::Specification
+name: mongoid_occurrences
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tomas Celizna
+- Asger Behncke Jacobsen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-01-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ice_cube
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+- !ruby/object:Gem::Dependency
+  name: mongoid-enum_attribute
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongoid_ice_cube_extension
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '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'
+- !ruby/object:Gem::Dependency
+  name: minitest-implicit-subject
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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'
+description: 
+email:
+- tomas.celizna@gmail.com
+- a@asgerbehnckejacobsen.dk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/mongoid_occurrences.rb
+- lib/mongoid_occurrences/aggregations/aggregation.rb
+- lib/mongoid_occurrences/aggregations/occurs_between.rb
+- lib/mongoid_occurrences/aggregations/occurs_from.rb
+- lib/mongoid_occurrences/aggregations/occurs_on.rb
+- lib/mongoid_occurrences/aggregations/occurs_until.rb
+- lib/mongoid_occurrences/daily_occurrence.rb
+- lib/mongoid_occurrences/daily_occurrence/has_scopes.rb
+- lib/mongoid_occurrences/has_fields_from_aggregation.rb
+- lib/mongoid_occurrences/has_occurrences.rb
+- lib/mongoid_occurrences/occurrence.rb
+- lib/mongoid_occurrences/occurrence/has_daily_occurrences.rb
+- lib/mongoid_occurrences/occurrence/has_operators.rb
+- lib/mongoid_occurrences/occurrence/has_schedule.rb
+- lib/mongoid_occurrences/queries/occurs_between.rb
+- lib/mongoid_occurrences/queries/occurs_from.rb
+- lib/mongoid_occurrences/queries/occurs_on.rb
+- lib/mongoid_occurrences/queries/occurs_until.rb
+- lib/mongoid_occurrences/queries/query.rb
+- lib/mongoid_occurrences/version.rb
+- mongoid_occurrences.gemspec
+homepage: https://github.com/tomasc/mongoid_occurrences
+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: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Facilitates aggregations for events with multiple occurrences or a recurring
+  schedule.
+test_files: []