ice_cube_model 0.0.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: edf86a2a7d7d80588e3965e382facda1e36284f5
-  data.tar.gz: 567a5ff73291f7ef031072d47b95f0d1303fd096
+  metadata.gz: bcfcf6653953d60c0d1d4f421c25f7df4a743ba9
+  data.tar.gz: e4a733da032f4a22d1614fb5de13437dd3272fa5
 SHA512:
-  metadata.gz: bbd4dc7514a93379baf57c39891eded3f3eb7f27d8b93faeaa998794117f86cc0d57b0d6566c0a5d2a8f557471e0c0062e13f57ef6c7036ce86a22c31c4b21c4
-  data.tar.gz: 290d0270530a2467df0c4c2ecafde88d3ed4763e818a62709f909afd551941ff1bcf376ca9a1cbe73a3a05b5b0fe13798b485453381ebc6db7121a15d3c66a27
+  metadata.gz: 193bcaa3deb4eaeb58a3aa926177c6fe12f2e7dc3109adf3e2ed2b0ca755075b8b9839e60d784849e66bec7bb1baf6e041c65c6f616decab4480870b55816c51
+  data.tar.gz: d701384517b7ca81747f17dd3b1617b633bf608824aebe38806296242a6a480f5c4ad2c630bad590111ff9cdb9fadf82d28bb53718d1dcf3b345beb4ab351b1a

data/README.md

@@ -119,6 +119,5 @@ end
 - Supports inheritance but will not pick up dynamic changes in parent class parameter mappings.
 
 ## todo
-- Add support for time options
 - Allow mapping of a single cron expression (string) field, rather than individual fields.
 

data/ice_cube_model.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   ##
   # Dependencies
   #
-  s.add_runtime_dependency 'ice_cube_cron', '~> 0.0'
+  s.add_runtime_dependency 'ice_cube_cron', '~> 1'
 
   ##
   # Development Dependencies

data/lib/ice_cube_model.rb

@@ -7,3 +7,4 @@ require 'active_support/core_ext/integer'
 require 'ice_cube_model/version'
 require 'ice_cube_model/util'
 require 'ice_cube_model/base'
+require 'ice_cube_model/delegator'

data/lib/ice_cube_model/base.rb

@@ -1,23 +1,5 @@
 module IceCubeModel
   module Base
-    DELEGATED_METHODS = [
-      :occurrences,
-      :all_occurrences,
-      :all_occurrences_enumerator,
-      :next_occurrences,
-      :next_occurrence,
-      :previous_occurrences,
-      :previous_occurrence,
-      :remaining_occurrences,
-      :remaining_occurrences_enumerator,
-      :occurrences_between,
-      :occurs_between?,
-      :occurring_between?,
-      :occurs_on?,
-      :first,
-      :last
-    ]
-
     def self.included(base)
       base.extend(::IceCubeModel::Base::ClassMethods)
     end
@@ -26,32 +8,6 @@ module IceCubeModel
       ::IceCube::Schedule.from_cron(read_repeat_parameter(:repeat_start_date), read_repeat_params)
     end
 
-    def respond_to?(name, include_private = false)
-      ## Does respond to delegated methods. method_missing will lazy define them as they are used.
-      return true if DELEGATED_METHODS.include?(name.to_sym)
-      return true if self.class.repeat_parameter_mappings.values.include?(name.to_sym)
-      super
-    end
-
-    # TODO: For backward compatibility. Remove before prod ready release.
-    delegate :occurrences_between, :to => :schedule
-    alias_method :events_between, :occurrences_between
-
-    ##
-    # Implementing method_missing as a *lazy* delegator. Doing this to prevent overwriting
-    # target class' methods.
-    #
-    def method_missing(name, *args, &block)
-      if DELEGATED_METHODS.include?(name.to_sym)
-        self.class.send(:define_method, name.to_sym) do |*method_args|
-          schedule.send(name, *method_args, &block)
-        end
-        send(name, *args)
-      else
-        super
-      end
-    end
-
   private
 
     def read_repeat_parameter(param_name)
@@ -66,8 +22,10 @@ module IceCubeModel
         :repeat_interval => read_repeat_parameter(:repeat_interval),
         :repeat_year => read_repeat_parameter(:repeat_year),
         :repeat_month => read_repeat_parameter(:repeat_month),
-        :repeat_day => read_repeat_parameter(:repeat_day),
-        :repeat_weekday => read_repeat_parameter(:repeat_weekday),
+        :repeat_day_of_month => read_repeat_parameter(:repeat_day_of_month),
+        :repeat_day_of_week => read_repeat_parameter(:repeat_day_of_week),
+        :repeat_hour => read_repeat_parameter(:repeat_hour),
+        :repeat_minute => read_repeat_parameter(:repeat_minute),
         :repeat_until => read_repeat_parameter(:repeat_until)
       }
     end

data/lib/ice_cube_model/delegator.rb

@@ -0,0 +1,27 @@
+module IceCubeModel
+  module Delegator
+    DELEGATED_METHODS = [
+      :occurrences,
+      :all_occurrences,
+      :all_occurrences_enumerator,
+      :next_occurrences,
+      :next_occurrence,
+      :previous_occurrences,
+      :previous_occurrence,
+      :remaining_occurrences,
+      :remaining_occurrences_enumerator,
+      :occurrences_between,
+      :occurs_between?,
+      :occurring_between?,
+      :occurs_on?,
+      :first,
+      :last
+    ]
+
+    def self.included(_base)
+      DELEGATED_METHODS.each do |name|
+        delegate name, :to => :schedule
+      end
+    end
+  end
+end

data/lib/ice_cube_model/version.rb

@@ -1,3 +1,3 @@
 module IceCubeModel
-  VERSION = '0.0.4'
+  VERSION = '1.0.0'
 end

data/spec/lib/ice_cube_model/base_spec.rb

@@ -1,38 +1,6 @@
 require 'spec_helper'
 
 describe ::IceCubeModel do
-  class HashAttrs
-    def initialize(attributes = {})
-      @attributes = {
-        :repeat_start_date => nil,
-        :repeat_interval => nil,
-        :repeat_year => nil,
-        :repeat_month => nil,
-        :repeat_day => nil,
-        :repeat_weekday => nil,
-        :repeat_week => nil,
-        :repeat_until => nil
-      }.merge(attributes)
-    end
-
-    def method_missing(m, *args, &_block)
-      if m =~ /[a-z_]+=/
-        attribute = m.to_s.strip.chop.to_sym
-        return @attributes[attribute] = args[0] if @attributes.key?(attribute)
-      else
-        return @attributes[m] if @attributes.key?(m)
-      end
-
-      fail ArgumentError, "Method `#{m}` doesn't exist."
-    end
-
-    def respond_to?(name, _include_private = false)
-      return true if @attributes.key?(name)
-
-      super
-    end
-  end
-
   class IceCubeObj < HashAttrs
     include ::IceCubeModel::Base
   end
@@ -43,264 +11,25 @@ describe ::IceCubeModel do
     )
   end
 
-  context 'repeat options' do
-    describe 'monthly' do
-      before { ice_cube_model.repeat_day = '1' }
-
-      it 'for same day' do
-        expect(ice_cube_model.events_between(::Date.new(2015, 7, 1), ::Date.new(2015, 7, 1))).to eq([::Date.new(2015, 7, 1)])
-      end
-
-      it 'for multiple months' do
-        expect(ice_cube_model.events_between(::Date.new(2015, 7, 1), ::Date.new(2015, 9, 1))).to eq([::Date.new(2015, 7, 1), ::Date.new(2015, 8, 1), ::Date.new(2015, 9, 1)])
-      end
-    end
-
-    describe 'twice monthly' do
-      before { ice_cube_model.repeat_day = '1,15' }
-
-      it 'for one month' do
-        expect(ice_cube_model.events_between(::Date.new(2015, 7, 1), ::Date.new(2015, 7, 31))).to eq([::Date.new(2015, 7, 1), ::Date.new(2015, 7, 15)])
-      end
-
-      it 'for two months' do
-        expect(ice_cube_model.events_between(::Date.new(2015, 7, 1), ::Date.new(2015, 8, 31))).to eq([::Date.new(2015, 7, 1), ::Date.new(2015, 7, 15), ::Date.new(2015, 8, 1), ::Date.new(2015, 8, 15)])
-      end
-    end
-
-    describe 'bi-monthly' do
-      let(:ice_cube_model) do
-        ::IceCubeObj.new(
-          :repeat_start_date => ::Date.new(2015, 5, 1),
-          :repeat_day => '1',
-          :repeat_interval => '2'
-        )
-      end
-
-      it 'for one month' do
-        expect(ice_cube_model.events_between(::Date.new(2015, 7, 1), ::Date.new(2015, 7, 31))).to eq([::Date.new(2015, 7, 1)])
-      end
-
-      it 'for multiple months' do
-        expect(ice_cube_model.events_between(::Date.new(2015, 7, 1), ::Date.new(2015, 10, 31))).to eq([::Date.new(2015, 7, 1), ::Date.new(2015, 9, 1)])
-      end
-    end
-
-    describe 'every week' do
-      let(:ice_cube_model) do
-        ::IceCubeObj.new(
-          :repeat_start_date => ::Date.new(2015, 7, 6),
-          :repeat_weekday => '1',
-          :repeat_day => nil
-        )
-      end
-
-      it 'for one week' do
-        expect(
-          ice_cube_model.events_between(
-            ::Date.new(2015, 7, 1),
-            ::Date.new(2015, 7, 7)
-          )
-        ).to eq([::Date.new(2015, 7, 6)])
-      end
-
-      it 'for one month' do
-        expect(
-          ice_cube_model.events_between(
-            ::Date.new(2015, 7, 1),
-            ::Date.new(2015, 8, 31)
-          )
-        ).to eq(
-          [
-            ::Date.new(2015, 7, 6),
-            ::Date.new(2015, 7, 13),
-            ::Date.new(2015, 7, 20),
-            ::Date.new(2015, 7, 27),
-            ::Date.new(2015, 8, 3),
-            ::Date.new(2015, 8, 10),
-            ::Date.new(2015, 8, 17),
-            ::Date.new(2015, 8, 24),
-            ::Date.new(2015, 8, 31)
-          ]
-        )
-      end
-    end
-
-    describe 'bi-weekly' do
-      let(:ice_cube_model) do
-        ::IceCubeObj.new(
-          :repeat_start_date => ::Date.new(2015, 7, 6),
-          :repeat_weekday => '1',
-          :repeat_day => nil,
-          :repeat_interval => '2'
-        )
-      end
-
-      it 'for one week' do
-        expect(
-          ice_cube_model.events_between(
-            ::Date.new(2015, 7, 1),
-            ::Date.new(2015, 7, 7)
-          )
-        ).to eq([::Date.new(2015, 7, 6)])
-      end
-
-      it 'for two months' do
-        expect(
-          ice_cube_model.events_between(
-            ::Date.new(2015, 7, 1),
-            ::Date.new(2015, 8, 31)
-          )
-        ).to eq(
-          [
-            ::Date.new(2015, 7, 6),
-            # ::Date.new(2015, 7, 13),
-            ::Date.new(2015, 7, 20),
-            # ::Date.new(2015, 7, 27),
-            ::Date.new(2015, 8, 3),
-            # ::Date.new(2015, 8, 10),
-            ::Date.new(2015, 8, 17),
-            # ::Date.new(2015, 8, 24),
-            ::Date.new(2015, 8, 31)
-          ]
-        )
-      end
-    end
-
-    describe 'annually' do
-      let(:ice_cube_model) do
-        ::IceCubeObj.new(
-          :repeat_start_date => ::Date.new(2015, 1, 1),
-          :repeat_month => 2,
-          :repeat_day => 1
-        )
-      end
-
-      it 'for one year' do
-        expect(ice_cube_model.events_between(::Date.new(2015, 1, 1), ::Date.new(2015, 12, 31))).to eq([::Date.new(2015, 2, 1)])
-      end
-
-      it 'for two years' do
-        expect(ice_cube_model.events_between(::Date.new(2015, 1, 1), ::Date.new(2016, 12, 31))).to eq([::Date.new(2015, 2, 1), ::Date.new(2016, 2, 1)])
-      end
-    end
-
-    describe 'bi-annually' do
-      let(:ice_cube_model) do
-        ::IceCubeObj.new(
-          :repeat_start_date => ::Date.new(2015, 1, 1),
-          :repeat_interval => 2,
-          :repeat_month => 2,
-          :repeat_day => 1
-        )
-      end
-
-      it 'for two years' do
-        expect(ice_cube_model.events_between(::Date.new(2015, 1, 1), ::Date.new(2016, 12, 31))).to eq([::Date.new(2015, 2, 1)])
-      end
-    end
-
-    describe 'last weekday of month' do
-      context '31 day month' do
-        let(:ice_cube_model) do
-          ::IceCubeObj.new(
-            :repeat_start_date => ::Date.new(2015, 1, 1),
-            :repeat_weekday => '5L'
-          )
-        end
-
-        it 'for one month' do
-          expect(ice_cube_model.events_between(::Date.new(2015, 12, 1), ::Date.new(2015, 12, 31))).to eq([::Date.new(2015, 12, 25)])
-        end
-      end
-
-      context '29 day month' do
-        let(:ice_cube_model) do
-          ::IceCubeObj.new(
-            :repeat_start_date => ::Date.new(2015, 1, 1),
-            :repeat_weekday => '3L'
-          )
-        end
-
-        it 'for one month' do
-          expect(ice_cube_model.events_between(::Date.new(2016, 2, 1), ::Date.new(2016, 2, 29))).to eq([::Date.new(2016, 2, 24)])
-        end
-      end
-    end
-
-    describe 'last day of month' do
-      context '31 day month' do
-        let(:ice_cube_model) do
-          ::IceCubeObj.new(
-            :repeat_start_date => ::Date.new(2015, 1, 1),
-            :repeat_day => 'L'
-          )
-        end
-
-        it 'for one multiple months' do
-          expect(ice_cube_model.events_between(::Date.new(2015, 12, 1), ::Date.new(2016, 3, 1))).to eq([::Date.new(2015, 12, 31), ::Date.new(2016, 1, 31), ::Date.new(2016, 2, 29)])
-        end
-      end
-    end
-
-    describe 'Nth day of week of month' do
-      let(:ice_cube_model) do
-        ::IceCubeObj.new(
-          :repeat_start_date => ::Date.new(2015, 1, 1),
-          :repeat_weekday => '1#2'
-        )
-      end
-
-      it 'for one month' do
-        expect(ice_cube_model.events_between(::Date.new(2016, 2, 1), ::Date.new(2016, 2, 29))).to eq([::Date.new(2016, 2, 8)])
-      end
-
-      it 'for mutiple months' do
-        expect(ice_cube_model.events_between(::Date.new(2016, 2, 1), ::Date.new(2016, 4, 30))).to eq([::Date.new(2016, 2, 8), ::Date.new(2016, 3, 14), ::Date.new(2016, 4, 11)])
-      end
-    end
-  end
-
-  context 'every month until date' do
-    let(:ice_cube_model) do
-      ::IceCubeObj.new(
-        :repeat_start_date => ::Date.new(2015, 1, 1),
-        :repeat_day => '1',
-        :repeat_until => ::Date.new(2015, 3, 1)
-      )
-    end
-
-    it 'ends on specified end date' do
-      expect(ice_cube_model.events_between(::Date.new(2015, 1, 1), ::Date.new(2015, 6, 30))).to eq([::Date.new(2015, 1, 1), ::Date.new(2015, 2, 1), ::Date.new(2015, 3, 1)])
-    end
-  end
-
-  context 'input types' do
-    let(:ice_cube_model) do
-      ::IceCubeObj.new(
-        :repeat_start_date => ::DateTime.new(2015, 5, 1),
-        :repeat_day => '1',
-        :repeat_interval => '2'
-      )
-    end
-
-    it 'handles ::DateTime as input' do
-      expect(ice_cube_model.events_between(::Date.new(2015, 7, 1), ::Date.new(2015, 7, 31))).to eq([::Date.new(2015, 7, 1)])
-    end
-
-    it 'handles integer (epoch) as input' do
-      ice_cube_model.repeat_start_date = 1_430_438_400 # Fri, 01 May 2015 00:00:00 GMT
-      expect(ice_cube_model.events_between(::Date.new(2015, 7, 1), ::Date.new(2015, 7, 31))).to eq([::DateTime.new(2015, 7, 1)])
-    end
-  end
-
-  context '::IceCubeModel::Base' do
-    describe '#events_between' do
-      it 'should emit [::Time]' do
-        results = ice_cube_model.events_between(::Date.new(2015, 7, 1), ::Date.new(2015, 7, 31))
-        expect(results).to eq([::Date.new(2015, 7, 1)])
-        expect(results[0]).to be_a(::Time)
-      end
+  describe '.schedule' do
+    it 'assigns all information' do
+      ice_cube_model.repeat_interval = 1
+      ice_cube_model.repeat_year = 2015
+      ice_cube_model.repeat_month = 2
+      ice_cube_model.repeat_day_of_month = 3
+      ice_cube_model.repeat_day_of_week = 4
+      ice_cube_model.repeat_hour = 5
+      ice_cube_model.repeat_minute = 6
+
+      validations = ice_cube_model.schedule.recurrence_rules.first.validations
+
+      expect(validations[:interval].first.interval).to eq(1)
+      expect(validations[:year].first.value).to eq(2015)
+      expect(validations[:month_of_year].first.value).to eq(2)
+      expect(validations[:day_of_month].first.value).to eq(3)
+      expect(validations[:day].first.value).to eq(4)
+      expect(validations[:hour_of_day].first.value).to eq(5)
+      expect(validations[:minute_of_hour].first.value).to eq(6)
     end
   end
 
@@ -308,10 +37,11 @@ describe ::IceCubeModel do
     describe '#with_repeat_param' do
       class IceCubeObjWithParameterMappings < HashAttrs
         include ::IceCubeModel::Base
+        include ::IceCubeModel::Delegator
 
         with_repeat_param(:repeat_start_date, :start_date) # remap attribute to another
         with_repeat_param(:repeat_interval, :interval)     # remap attribute to a method
-        with_repeat_param(:repeat_day, -> { 5 })           # map parameter to lambda
+        with_repeat_param(:repeat_day_of_month, -> { 5 }) # map parameter to lambda
 
         def initialize(options = {})
           super(
@@ -334,14 +64,14 @@ describe ::IceCubeModel do
       end
 
       it 'should use class mappings' do
-        expect(ice_cube_model.events_between(::Date.new(2015, 1, 1), ::Date.new(2015, 12, 31))).to eq([::Date.new(2015, 2, 5)])
+        expect(ice_cube_model.schedule.occurrences_between(::Date.new(2015, 1, 1), ::Date.new(2015, 12, 31))).to eq([::Date.new(2015, 2, 5)])
       end
 
       context 'with inheritance' do
         class IceCubeObjWithParameterMappingsChild < IceCubeObjWithParameterMappings
           with_repeat_param(:repeat_start_date, :starting) # remap attribute to another
           with_repeat_param(:repeat_interval, :interval)   # remap attribute to a method
-          # with_repeat_param(:repeat_day, -> { 5 })       # comes from parent ::IceCubeObjWithParameterMappings
+          # with_repeat_param(:repeat_day_of_month, -> { 5 })       # comes from parent ::IceCubeObjWithParameterMappings
 
           def initialize(options = {})
             super(
@@ -363,121 +93,38 @@ describe ::IceCubeModel do
         end
 
         it 'should inherit mappings and remap new mappings' do
-          expect(ice_cube_model.events_between(::Date.new(2015, 1, 1), ::Date.new(2015, 4, 30))).to eq([::Date.new(2015, 1, 5), ::Date.new(2015, 3, 5)])
+          expect(ice_cube_model.schedule.occurrences_between(::Date.new(2015, 1, 1), ::Date.new(2015, 4, 30))).to eq([::Date.new(2015, 1, 5), ::Date.new(2015, 3, 5)])
         end
       end
 
       context 'with missing parameters' do
         class IceCubeObjWithMissingParameters
           include ::IceCubeModel::Base
+          include ::IceCubeModel::Delegator
 
           attr_accessor :repeat_start_date
-          attr_accessor :repeat_day
+          attr_accessor :repeat_day_of_month
+
+          with_repeat_param :repeat_hour, -> { 0 }
+          with_repeat_param :repeat_minute, -> { 0 }
         end
 
         it 'should work when class missing parameters' do
           ice_cube_model = ::IceCubeObjWithMissingParameters.new
 
           ice_cube_model.repeat_start_date = ::Date.new(2015, 1, 1)
-          ice_cube_model.repeat_day = 2
+          ice_cube_model.repeat_day_of_month = 2
 
-          expect(ice_cube_model.events_between(::Date.new(2015, 1, 1), ::Date.new(2015, 2, 28))).to eq([::Date.new(2015, 1, 2), ::Date.new(2015, 2, 2)])
+          expect(ice_cube_model.schedule.occurrences_between(::Date.new(2015, 1, 1), ::Date.new(2015, 2, 28))).to eq([::Date.new(2015, 1, 2), ::Date.new(2015, 2, 2)])
         end
 
         it '#respond_to?' do
           ice_cube_model = ::IceCubeObjWithMissingParameters.new
-          expect(ice_cube_model.respond_to?(:repeat_day)).to be(true)
+          expect(ice_cube_model.respond_to?(:repeat_day_of_month)).to be(true)
           expect(ice_cube_model.respond_to?(:repeat_interval)).to be(false)
           expect(ice_cube_model.respond_to?(:methods)).to be(true)
         end
       end
     end
   end
-
-  describe 'delagated methods' do
-    let(:ice_cube_model) do
-      ::IceCubeObj.new(
-        :repeat_start_date => ::Date.new(2015, 6, 1),
-        :repeat_day => 5
-      )
-    end
-
-    it '#occurrences' do
-      expect(ice_cube_model.occurrences(::Date.new(2015, 8, 1))).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
-    end
-
-    it '#all_occurrences' do
-      ice_cube_model.repeat_until = ::Date.new(2015, 8, 1)
-      expect(ice_cube_model.all_occurrences).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
-    end
-
-    it '#all_occurrences_enumerator' do
-      ice_cube_model.repeat_until = ::Date.new(2015, 8, 1)
-      expect(ice_cube_model.all_occurrences_enumerator.map { |occurrence| occurrence }).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
-    end
-
-    it '#next_occurrences' do
-      expect(ice_cube_model.next_occurrences(2, ::Date.new(2015, 6, 1))).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
-    end
-
-    it '#next_occurrence' do
-      expect(ice_cube_model.next_occurrence(::Date.new(2015, 6, 1))).to eq(::Date.new(2015, 6, 5))
-    end
-
-    it '#previous_occurrences' do
-      expect(ice_cube_model.previous_occurrences(2, ::Date.new(2015, 8, 1))).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
-    end
-
-    it '#previous_occurrence' do
-      expect(ice_cube_model.previous_occurrence(::Date.new(2015, 8, 1))).to eq(::Date.new(2015, 7, 5))
-    end
-
-    it '#remaining_occurrences' do
-      ice_cube_model.repeat_until = ::Date.new(2015, 8, 1)
-      expect(ice_cube_model.remaining_occurrences(::Date.new(2015, 6, 1))).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
-    end
-
-    it '#remaining_occurrences_enumerator' do
-      ice_cube_model.repeat_until = ::Date.new(2015, 8, 1)
-      expect(ice_cube_model.remaining_occurrences_enumerator(::Date.new(2015, 6, 1)).map { |occurrence| occurrence }).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
-    end
-
-    it '#occurrences_between' do
-      expect(ice_cube_model.occurrences_between(::Date.new(2015, 6, 1), ::Date.new(2015, 8, 1))).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
-      expect(ice_cube_model.events_between(::Date.new(2015, 6, 1), ::Date.new(2015, 8, 1))).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
-    end
-
-    it '#occurs_between?' do
-      expect(ice_cube_model.occurs_between?(::Date.new(2015, 7, 1), ::Date.new(2015, 8, 1))).to be(true)
-    end
-
-    it '#occurring_between?' do
-      expect(ice_cube_model.occurring_between?(::Date.new(2015, 6, 1), ::Date.new(2015, 8, 1))).to be(true)
-    end
-
-    it '#occurs_on?' do
-      expect(ice_cube_model.occurs_on?(::Date.new(2015, 6, 5))).to be(true)
-    end
-
-    it '#occurring_at?' do
-      skip 'Time options not implemented yet'
-    end
-
-    it '#conflicts_with?' do
-      skip 'Time options not implemented yet'
-    end
-
-    it '#occurs_at?' do
-      skip 'Time options not implemented yet'
-    end
-
-    it '#first' do
-      expect(ice_cube_model.first(2)).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
-    end
-
-    it '#last' do
-      ice_cube_model.repeat_until = ::Date.new(2015, 8, 1)
-      expect(ice_cube_model.last(2)).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
-    end
-  end
 end

data/spec/lib/ice_cube_model/delegator_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe ::IceCubeModel::Delegator do
+  class IceCubeObjWithDelegates < HashAttrs
+    include ::IceCubeModel::Base
+    include ::IceCubeModel::Delegator
+  end
+
+  let(:ice_cube_model) do
+    ::IceCubeObjWithDelegates.new(
+      :repeat_start_date => ::Date.new(2015, 6, 1),
+      :repeat_day_of_month => 5,
+      :repeat_hour => 0,
+      :repeat_minute => 0
+    )
+  end
+
+  it '#occurrences' do
+    expect(ice_cube_model.occurrences(::Date.new(2015, 8, 1))).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
+  end
+
+  it '#all_occurrences' do
+    ice_cube_model.repeat_until = ::Date.new(2015, 8, 1)
+    expect(ice_cube_model.all_occurrences).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
+  end
+
+  it '#all_occurrences_enumerator' do
+    ice_cube_model.repeat_until = ::Date.new(2015, 8, 1)
+    expect(ice_cube_model.all_occurrences_enumerator.map { |occurrence| occurrence }).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
+  end
+
+  it '#next_occurrences' do
+    expect(ice_cube_model.next_occurrences(2, ::Date.new(2015, 6, 1))).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
+  end
+
+  it '#next_occurrence' do
+    expect(ice_cube_model.next_occurrence(::Date.new(2015, 6, 1))).to eq(::Date.new(2015, 6, 5))
+  end
+
+  it '#previous_occurrences' do
+    expect(ice_cube_model.previous_occurrences(2, ::Date.new(2015, 8, 1))).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
+  end
+
+  it '#previous_occurrence' do
+    expect(ice_cube_model.previous_occurrence(::Date.new(2015, 8, 1))).to eq(::Date.new(2015, 7, 5))
+  end
+
+  it '#remaining_occurrences' do
+    ice_cube_model.repeat_until = ::Date.new(2015, 8, 1)
+    expect(ice_cube_model.remaining_occurrences(::Date.new(2015, 6, 1))).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
+  end
+
+  it '#remaining_occurrences_enumerator' do
+    ice_cube_model.repeat_until = ::Date.new(2015, 8, 1)
+    expect(ice_cube_model.remaining_occurrences_enumerator(::Date.new(2015, 6, 1)).map { |occurrence| occurrence }).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
+  end
+
+  it '#occurrences_between' do
+    expect(ice_cube_model.occurrences_between(::Date.new(2015, 6, 1), ::Date.new(2015, 8, 1))).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
+  end
+
+  it '#occurs_between?' do
+    expect(ice_cube_model.occurs_between?(::Date.new(2015, 7, 1), ::Date.new(2015, 8, 1))).to be(true)
+  end
+
+  it '#occurring_between?' do
+    expect(ice_cube_model.occurring_between?(::Date.new(2015, 6, 1), ::Date.new(2015, 8, 1))).to be(true)
+  end
+
+  it '#occurs_on?' do
+    expect(ice_cube_model.occurs_on?(::Date.new(2015, 6, 5))).to be(true)
+  end
+
+  it '#occurring_at?' do
+    skip 'Time options not implemented yet'
+  end
+
+  it '#conflicts_with?' do
+    skip 'Time options not implemented yet'
+  end
+
+  it '#occurs_at?' do
+    skip 'Time options not implemented yet'
+  end
+
+  it '#first' do
+    expect(ice_cube_model.first(2)).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
+  end
+
+  it '#last' do
+    ice_cube_model.repeat_until = ::Date.new(2015, 8, 1)
+    expect(ice_cube_model.last(2)).to eq([::Date.new(2015, 6, 5), ::Date.new(2015, 7, 5)])
+  end
+end

data/spec/spec_helper.rb

@@ -44,3 +44,5 @@ RSpec.configure do |config|
     mocks.verify_partial_doubles = true
   end
 end
+
+Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each { |f| require f }

data/spec/support/hash_attrs.rb

@@ -0,0 +1,33 @@
+class HashAttrs
+  def initialize(attributes = {})
+    @attributes = {
+      :repeat_start_date => nil,
+      :repeat_interval => nil,
+      :repeat_year => nil,
+      :repeat_month => nil,
+      :repeat_day_of_month => nil,
+      :repeat_day_of_week => nil,
+      :repeat_week => nil,
+      :repeat_hour => 0,
+      :repeat_minute => 0,
+      :repeat_until => nil
+    }.merge(attributes)
+  end
+
+  def method_missing(m, *args, &_block)
+    if m =~ /[a-z_]+=/
+      attribute = m.to_s.strip.chop.to_sym
+      return @attributes[attribute] = args[0] if @attributes.key?(attribute)
+    else
+      return @attributes[m] if @attributes.key?(m)
+    end
+
+    fail ArgumentError, "Method `#{m}` doesn't exist."
+  end
+
+  def respond_to?(name, _include_private = false)
+    return true if @attributes.key?(name)
+
+    super
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ice_cube_model
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Matt Nichols
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-28 00:00:00.000000000 Z
+date: 2015-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ice_cube_cron
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.0'
+        version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.0'
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -96,11 +96,14 @@ files:
 - ice_cube_model.gemspec
 - lib/ice_cube_model.rb
 - lib/ice_cube_model/base.rb
+- lib/ice_cube_model/delegator.rb
 - lib/ice_cube_model/util.rb
 - lib/ice_cube_model/version.rb
 - spec/lib/ice_cube_model/base_spec.rb
+- spec/lib/ice_cube_model/delegator_spec.rb
 - spec/lib/ice_cube_model/util_spec.rb
 - spec/spec_helper.rb
+- spec/support/hash_attrs.rb
 homepage: https://github.com/mattnichols/ice_cube_model
 licenses:
 - MIT
@@ -127,5 +130,7 @@ specification_version: 4
 summary: Extend any class with ice_cube (calendar repeating events) capabilities.
 test_files:
 - spec/lib/ice_cube_model/base_spec.rb
+- spec/lib/ice_cube_model/delegator_spec.rb
 - spec/lib/ice_cube_model/util_spec.rb
 - spec/spec_helper.rb
+- spec/support/hash_attrs.rb