ice_cube_model 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cefa6dfe8e2c38fdf4d6440fc779013c3b983133
-  data.tar.gz: e0ffa905699ef4e8de88e4859a106874864b76de
+  metadata.gz: 1128479e22af71166bf026bf19398f9f26de440f
+  data.tar.gz: dbb48be74fe828c79b005855278c7699e83f534f
 SHA512:
-  metadata.gz: 24235214a4c1a1296c4b39f4fd331e1e214fc2ac312aab69fb9b6153977a555bf8022706729406cbff0fa35fc8de8e667f6022cca82c1c26b045669e3a0c466e
-  data.tar.gz: a4b9fad410e469dcb850ec87953444e956b3db1f11b3335742fadd824fb6616bddd6c2b9ce816256875b5b4d4d3b98993b70c0a311f4c57e280e19c3a5b6b851
+  metadata.gz: ceec5f3cba596bf356dd19ce106dbd1910e24d53f1a78cb400b28160d7c680d3df28c1fae2eb32621054a282d51b97620dae13d3479832c5c2654a521ac06237
+  data.tar.gz: 865e4a6b94862468c5075803c120d928ef990cb8569fb676ecf2dbef7a0ecac836ad95c9f33da8ba5709e2cacb57a2d08d3c85089d75325f0467953ecbf01528

data/.gitignore

@@ -34,3 +34,4 @@ Gemfile.lock
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc
+Guardfile

data/.rubocop.yml

@@ -12,3 +12,6 @@ Style/Documentation:
 
 Metrics/LineLength:
   Enabled: false
+
+Metrics/MethodLength:
+  Max: 15

data/README.md

@@ -1,7 +1,16 @@
 # ice_cube_model
-Extend any object with [ice_cube](https://github.com/seejohnrun/ice_cube) (calendar repeating event) capabilities.
+Extend any "cron-expression" object with [ice_cube](https://github.com/seejohnrun/ice_cube) (calendar repeating event) capabilities.
 
-Add ice_cube methods to classes (e.g. active_record, active_model).
+Add ice_cube methods to a class (e.g. active_record, active_model) that has cron expression fields.
+
+## description
+
+**ice_cube** is a sold library for projecting and querying recurrence rules. **Cron** is _the_ standard for expressing recurrence rules. If you have a model that stores cron fields in separate attributes, then this gem will allow you to map those attributes into ice_cube and execute projection and queries against it.
+
+The fields in the model can use standard cron expression syntax [explained here](https://en.wikipedia.org/wiki/Cron). This includes range expressions, series expressions, "last" day of month, Nth weekday of month, etc.
+
+PLEASE NOTE:
+This gem is a work-in-progress. Many features have yet to be implemented.
 
 ## installation
 
@@ -89,12 +98,28 @@ class Appointment
 end
 ```
 
+## recurrence rule examples (date)
+
+|desc|interval|year|month|day|weekday|
+|----|-------:|---:|----:|--:|------:|
+|1st of every month||||1||
+|1st and 15th of every month||||1,15||
+|every monday|||||1|
+|1st monday of every month|||||1#1|
+|ever other friday|2||||5|
+|every 6 months on the 5th|6|||5||
+|last friday of every month|||||5L|
+|last day every month||||L||
+
 ## notes
 - This gem is a work-in-progress.
 - `occurrences_between` is the only method currently supported.
 - Does not yet support all recurrence options. More coming.
+- Does not support inheritance. with_repeat_params called on child classes will mess with parent class' mappings.
 
 ## todo
-- Add more examples to specs and README
-- Add ability to do Nth types of repeats (e.g. last friday of the month, first and third tuesday of every month). These are supported by ice_cube.
+- Add support for repeat_end_date
+- Add support for inheritance
+- Add support for time
+- Allow mapping of a single cron expression (string) field, rather than individual fields.
 

data/ice_cube_model.gemspec

@@ -18,8 +18,7 @@ Gem::Specification.new do |s|
   ##
   # Dependencies
   #
-  s.add_dependency 'ice_cube', '= 0.13.0'
-  s.add_dependency 'activesupport', '>= 3.0.0'
+  s.add_dependency 'ice_cube_cron', '>= 0.0.2'
 
   ##
   # Development Dependencies
@@ -27,11 +26,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rake'
   s.add_development_dependency 'pry'
   s.add_development_dependency 'rspec'
-  s.add_development_dependency 'simplecov'
   s.add_development_dependency 'rubocop'
-  s.add_development_dependency 'guard'
-  s.add_development_dependency 'guard-rspec'
-  s.add_development_dependency 'guard-rubocop'
-  s.add_development_dependency 'spring'
-  s.add_development_dependency 'spring-commands-rspec'
 end

data/lib/ice_cube_model.rb

@@ -1,4 +1,5 @@
 require 'ice_cube'
+require 'ice_cube_cron'
 
 require 'active_support/core_ext/date'
 require 'active_support/core_ext/integer'

data/lib/ice_cube_model/base.rb

@@ -5,10 +5,12 @@ module IceCubeModel
     end
 
     def events_between(start, through)
-      params = read_cyclical_params
-      schedule = ::IceCubeModel::Util.build_schedule(params)
-      schedule.occurrences_between(::IceCubeModel::Util.sanitize_date_param(start), ::IceCubeModel::Util.sanitize_date_param(through)).map(&:to_date)
+      params = read_repeat_params
+      schedule = ::IceCube::Schedule.from_cron(read_repeat_parameter(:repeat_start_date), params)
+
+      schedule.occurrences_between(::IceCubeModel::Util.sanitize_date_param(start), ::IceCubeModel::Util.sanitize_date_param(through))
     end
+    alias_method :occurrences_between, :events_between
 
   private
 
@@ -16,14 +18,13 @@ module IceCubeModel
       send(self.class.repeat_parameter_mappings[param_name])
     end
 
-    def read_cyclical_params
+    def read_repeat_params
       {
-        :repeat_start_date => ::IceCubeModel::Util.sanitize_date_param(read_repeat_parameter(:repeat_start_date)),
-        :repeat_interval => ::IceCubeModel::Util.sanitize_integer_param(read_repeat_parameter(:repeat_interval)),
-        :repeat_year => ::IceCubeModel::Util.sanitize_integer_array_param(read_repeat_parameter(:repeat_year)),
-        :repeat_month => ::IceCubeModel::Util.sanitize_integer_array_param(read_repeat_parameter(:repeat_month)),
-        :repeat_day => ::IceCubeModel::Util.sanitize_integer_array_param(read_repeat_parameter(:repeat_day)),
-        :repeat_weekday => ::IceCubeModel::Util.sanitize_integer_array_param(read_repeat_parameter(:repeat_weekday))
+        :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)
       }
     end
 

data/lib/ice_cube_model/util.rb

@@ -1,30 +1,5 @@
 module IceCubeModel
   module Util
-    def self.build_schedule(params)
-      schedule = ::IceCube::Schedule.new(::IceCubeModel::Util.sanitize_date_param(params[:repeat_start_date]))
-      schedule.add_recurrence_rule ::IceCubeModel::Util.build_cyclical_repeat_rules(params)
-
-      schedule
-    end
-
-    def self.build_cyclical_repeat_rules(params)
-      rule = ::IceCubeModel::Util.build_root_recurrence_rule(params)
-
-      rule = rule.month_of_year(*params[:repeat_month]) unless params[:repeat_month].blank?
-      rule = rule.day_of_month(*params[:repeat_day]) unless params[:repeat_day].blank?
-      rule = rule.day(*params[:repeat_weekday]) unless params[:repeat_weekday].blank?
-
-      rule
-    end
-
-    def self.build_root_recurrence_rule(params)
-      interval = params[:repeat_interval]
-      return ::IceCube::Rule.yearly(interval) unless params[:repeat_month].blank?
-      return ::IceCube::Rule.weekly(interval) unless params[:repeat_weekday].blank?
-
-      ::IceCube::Rule.monthly(interval)
-    end
-
     def self.sanitize_date_param(date)
       date = date.to_time(:utc) if date.is_a?(::Date) && !date.is_a?(::DateTime)
       date = date.to_time.utc if date.is_a?(::DateTime)
@@ -32,19 +7,5 @@ module IceCubeModel
 
       date
     end
-
-    def self.sanitize_integer_array_param(param)
-      return nil if param.blank?
-      return param if param.is_a?(::Array)
-      return [param] if param.is_a?(::Integer)
-
-      param.split(',').map(&:to_i)
-    end
-
-    def self.sanitize_integer_param(param)
-      return 1 if param.blank?
-
-      param.to_i
-    end
   end
 end

data/lib/ice_cube_model/version.rb

@@ -1,3 +1,3 @@
 module IceCubeModel
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/spec/lib/ice_cube_model/base_spec.rb

@@ -0,0 +1,348 @@
+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
+      }.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
+  end
+
+  class IceCubeObj < HashAttrs
+    include ::IceCubeModel::Base
+  end
+
+  let(:ice_cube_model) do
+    ::IceCubeObj.new(
+      :repeat_start_date => ::Date.new(2015, 6, 1)
+    )
+  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 '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(::DateTime.new(2015, 7, 1), ::DateTime.new(2015, 7, 31))).to eq([::DateTime.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(::DateTime.new(2015, 7, 1), ::DateTime.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
+    end
+  end
+
+  context '::ClassMethods' do
+    describe '#with_repeat_param' do
+      class IceCubeObjWithParameterMappings < HashAttrs
+        include ::IceCubeModel::Base
+
+        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, -> { 1 })           # map parameter to lambda
+
+        def initialize(options = {})
+          super(
+            {
+              :start_date => nil
+            }.merge(options)
+          )
+        end
+
+        def interval
+          1
+        end
+      end
+
+      let(:ice_cube_model) do
+        ::IceCubeObjWithParameterMappings.new(
+          :start_date => ::Date.new(2015, 1, 1),
+          :repeat_month => 2
+        )
+      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, 1)])
+      end
+
+      class IceCubeObjWithParameterMappingsChild < IceCubeObjWithParameterMappings
+        # Adding these currently mess up parent class mappings
+        # with_repeat_param(:repeat_start_date, :starting) # remap attribute to another
+        # with_repeat_param(:repeat_interval, :interval)   # remap attribute to a method
+
+        def initialize(options = {})
+          super(
+            {
+              :starting => nil
+            }.merge(options)
+          )
+        end
+
+        def interval
+          2
+        end
+      end
+
+      it 'should support inheritance' do
+        ice_cube_model = ::IceCubeObjWithParameterMappingsChild.new(
+          :starting => ::Date.new(2015, 1, 1),
+          :repeat_day => 2
+        )
+
+        skip 'Not supported yet'
+        expect(ice_cube_model.events_between(::Date.new(2015, 1, 1), ::Date.new(2015, 4, 30))).to eq([::Date.new(2015, 1, 2), ::Date.new(2015, 3, 2)])
+      end
+    end
+  end
+end

data/spec/lib/ice_cube_model/util_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe ::IceCubeModel::Util do
+  describe '#sanitize_date_param' do
+    it 'should handle epoch time' do
+      expect(described_class.sanitize_date_param(1_430_438_400)).to eq(DateTime.new(2015, 5, 1, 0, 0, 0))
+    end
+
+    it 'should handle date' do
+      expect(described_class.sanitize_date_param(Date.new(2015, 5, 1))).to eq(DateTime.new(2015, 5, 1, 0, 0, 0))
+    end
+
+    it 'should handle datetime' do
+      expect(described_class.sanitize_date_param(DateTime.new(2015, 5, 1, 0, 0, 0))).to eq(DateTime.new(2015, 5, 1, 0, 0, 0))
+    end
+  end
+end

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ice_cube_model
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Matt Nichols
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-13 00:00:00.000000000 Z
+date: 2015-10-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.13.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.13.0
-- !ruby/object:Gem::Dependency
-  name: activesupport
+  name: ice_cube_cron
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 0.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 0.0.2
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -80,20 +66,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  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: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -108,76 +80,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '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-rspec
-  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-rubocop
-  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: spring
-  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: spring-commands-rspec
-  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'
 description: Add ice_cube methods to classes (e.g. active_record, active_model).
 email:
 - matt@nichols.name
@@ -196,8 +98,8 @@ files:
 - lib/ice_cube_model/base.rb
 - lib/ice_cube_model/util.rb
 - lib/ice_cube_model/version.rb
-- spec/lib/ice_cube_model_spec.rb
-- spec/lib/util_spec.rb
+- spec/lib/ice_cube_model/base_spec.rb
+- spec/lib/ice_cube_model/util_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/mattnichols/ice_cube_model
 licenses: []
@@ -223,6 +125,6 @@ signing_key:
 specification_version: 4
 summary: Extend any class with ice_cube (calendar repeating events) capabilities.
 test_files:
-- spec/lib/ice_cube_model_spec.rb
-- spec/lib/util_spec.rb
+- spec/lib/ice_cube_model/base_spec.rb
+- spec/lib/ice_cube_model/util_spec.rb
 - spec/spec_helper.rb

data/spec/lib/ice_cube_model_spec.rb

@@ -1,292 +0,0 @@
-require 'spec_helper'
-
-describe ::IceCubeModel do
-  class IceCubeObj
-    include ::IceCubeModel::Base
-
-    def initialize(options = {})
-      @options = {
-        :repeat_start_date => nil,
-        :repeat_interval => nil,
-        :repeat_year => nil,
-        :repeat_month => nil,
-        :repeat_day => nil,
-        :repeat_weekday => nil,
-        :repeat_week => nil
-      }.merge(options)
-    end
-
-    def method_missing(m, *_args, &_block)
-      return @options[m] if @options.key?(m)
-      fail ArgumentError, "Method `#{m}` doesn't exist."
-    end
-  end
-
-  describe 'monthly' do
-    let(:projector) do
-      ::IceCubeObj.new(
-        :repeat_start_date => ::Date.new(2015, 6, 1),
-        :repeat_day => '1'
-      )
-    end
-
-    it 'should emit [::Date]' do
-      results = projector.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(::Date)
-    end
-
-    it 'should render same day' do
-      expect(projector.events_between(::Date.new(2015, 7, 1), ::Date.new(2015, 7, 1))).to eq([::Date.new(2015, 7, 1)])
-    end
-
-    it 'should render across multiple months' do
-      expect(projector.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
-    let(:projector) do
-      ::IceCubeObj.new(
-        :repeat_start_date => ::Date.new(2015, 6, 1),
-        :repeat_day => '1,15'
-      )
-    end
-
-    it 'should render one month' do
-      expect(projector.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 'should render one month' do
-      expect(projector.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(:projector) do
-      ::IceCubeObj.new(
-        :repeat_start_date => ::Date.new(2015, 5, 1),
-        :repeat_day => '1',
-        :repeat_interval => '2'
-      )
-    end
-
-    it 'should render one month' do
-      expect(projector.events_between(::Date.new(2015, 7, 1), ::Date.new(2015, 7, 31))).to eq([::Date.new(2015, 7, 1)])
-    end
-
-    it 'should render multiple months' do
-      expect(projector.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(:projector) do
-      ::IceCubeObj.new(
-        :repeat_start_date => ::Date.new(2015, 7, 6),
-        :repeat_weekday => '1',
-        :repeat_day => nil
-      )
-    end
-
-    it 'should render one week' do
-      expect(
-        projector.events_between(
-          ::Date.new(2015, 7, 1),
-          ::Date.new(2015, 7, 7)
-        )
-      ).to eq([::Date.new(2015, 7, 6)])
-    end
-
-    it 'should render one month' do
-      expect(
-        projector.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 'every two weeks' do
-    let(:projector) do
-      ::IceCubeObj.new(
-        :repeat_start_date => ::Date.new(2015, 7, 6),
-        :repeat_weekday => '1',
-        :repeat_day => nil,
-        :repeat_interval => '2'
-      )
-    end
-
-    it 'should render one week' do
-      expect(
-        projector.events_between(
-          ::Date.new(2015, 7, 1),
-          ::Date.new(2015, 7, 7)
-        )
-      ).to eq([::Date.new(2015, 7, 6)])
-    end
-
-    it 'should render one month' do
-      expect(
-        projector.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(:projector) do
-      ::IceCubeObj.new(
-        :repeat_start_date => ::Date.new(2015, 1, 1),
-        :repeat_month => 2,
-        :repeat_day => 1
-      )
-    end
-
-    it 'should render one year' do
-      expect(projector.events_between(::Date.new(2015, 1, 1), ::Date.new(2015, 12, 31))).to eq([::Date.new(2015, 2, 1)])
-    end
-  end
-
-  describe 'bi-annually' do
-    let(:projector) do
-      ::IceCubeObj.new(
-        :repeat_start_date => ::Date.new(2015, 1, 1),
-        :repeat_interval => 2,
-        :repeat_month => 2,
-        :repeat_day => 1
-      )
-    end
-
-    it 'should render two year' do
-      expect(projector.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(:projector) do
-        ::IceCubeObj.new(
-          :repeat_start_date => ::Date.new(2015, 1, 1),
-          :repeat_day => '31, 30, 29, 28, 27, 26, 25',
-          :repeat_weekday => 5
-        )
-      end
-
-      it 'should render' do
-        expect(projector.events_between(::Date.new(2015, 12, 1), ::Date.new(2015, 12, 31))).to eq([::Date.new(2015, 12, 25)])
-      end
-    end
-
-    context '31 day month' do
-      let(:projector) do
-        ::IceCubeObj.new(
-          :repeat_start_date => ::Date.new(2015, 1, 1),
-          :repeat_day => '31, 30, 29, 28, 27, 26, 25',
-          :repeat_weekday => 1
-        )
-      end
-
-      it 'should render' do
-        expect(projector.events_between(::Date.new(2016, 2, 1), ::Date.new(2016, 2, 29))).to eq([::Date.new(2016, 2, 29)])
-      end
-    end
-  end
-
-  describe 'handles ::DateTime as input' do
-    let(:projector) do
-      ::IceCubeObj.new(
-        :repeat_start_date => ::DateTime.new(2015, 5, 1),
-        :repeat_day => '1',
-        :repeat_interval => '2'
-      )
-    end
-
-    it 'should render one month' do
-      expect(projector.events_between(::DateTime.new(2015, 7, 1), ::DateTime.new(2015, 7, 31))).to eq([::DateTime.new(2015, 7, 1)])
-    end
-  end
-
-  describe 'handles integer (epoch) as input' do
-    let(:projector) do
-      ::IceCubeObj.new(
-        :repeat_start_date => 1_430_438_400, # Fri, 01 May 2015 00:00:00 GMT
-        :repeat_day => '1',
-        :repeat_interval => '2'
-      )
-    end
-
-    it 'should render one month' do
-      expect(projector.events_between(::DateTime.new(2015, 7, 1), ::DateTime.new(2015, 7, 31))).to eq([::DateTime.new(2015, 7, 1)])
-    end
-  end
-
-  describe '::ClassMethods' do
-    class IceCubeObjWithParameterMappings
-      include ::IceCubeModel::Base
-
-      with_repeat_param(:repeat_start_date, :start_date) # remap parameter to another
-      with_repeat_param(:repeat_interval, :interval) # remap parameter to a method
-      with_repeat_param(:repeat_day, -> { 1 }) # map parameter to lambda
-
-      def initialize(options = {})
-        @options = {
-          :start_date => nil,
-          :repeat_interval => nil,
-          :repeat_year => nil,
-          :repeat_month => nil,
-          :repeat_day => nil,
-          :repeat_weekday => nil,
-          :repeat_week => nil
-        }.merge(options)
-      end
-
-      def interval
-        1
-      end
-
-      def method_missing(m, *_args, &_block)
-        return @options[m] if @options.key?(m)
-        fail ArgumentError, "Method `#{m}` doesn't exist."
-      end
-    end
-
-    let(:projector) do
-      ::IceCubeObjWithParameterMappings.new(
-        :start_date => ::Date.new(2015, 1, 1),
-        :repeat_month => 2
-      )
-    end
-
-    it 'should render correctly' do
-      expect(projector.events_between(::Date.new(2015, 1, 1), ::Date.new(2015, 12, 31))).to eq([::Date.new(2015, 2, 1)])
-    end
-  end
-end

data/spec/lib/util_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe ::IceCubeModel::Util do
-  describe '#sanitize_date_param' do
-    it 'should handle epoch time' do
-      expect(::IceCubeModel::Util.sanitize_date_param(1_430_438_400)).to eq(DateTime.new(2015, 5, 1, 0, 0, 0))
-    end
-
-    it 'should handle date' do
-      expect(::IceCubeModel::Util.sanitize_date_param(Date.new(2015, 5, 1))).to eq(DateTime.new(2015, 5, 1, 0, 0, 0))
-    end
-
-    it 'should handle datetime' do
-      expect(::IceCubeModel::Util.sanitize_date_param(DateTime.new(2015, 5, 1, 0, 0, 0))).to eq(DateTime.new(2015, 5, 1, 0, 0, 0))
-    end
-  end
-end