ice_cube_cron 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 35437710e09561f1e31c5f37b0e612a21866395e
+  data.tar.gz: e4648fbf6cd9fee9e5ad7f2f260d2bbc4eeb4412
+SHA512:
+  metadata.gz: 6edd59aebe07b5926ffe46ee99faa64ac4491b202c837ae09dbad0ade219eb4df2de35a1ad7946363755c953e8d56d6fa4462c9ac436e29cde7bf64c98b76696
+  data.tar.gz: 16c1988525cf23b6fb90f40b0a188dde5ce72fd45fdcd3582c75dd05f2aafc1112149c1670231520f7a34ad5fdf04b4917d7e9ee894343bfba8c63cc2da18220

data/.gitignore

@@ -0,0 +1,36 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+vendor/cache

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.rubocop.yml

@@ -0,0 +1,17 @@
+AllCops:
+  DisplayCopNames: true
+
+Style/HashSyntax:
+  EnforcedStyle: hash_rockets
+
+Style/AccessModifierIndentation:
+  EnforcedStyle: outdent
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 15

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+# DEVUP--
+gem 'guard-zeus', :group => :development
+gem 'guard-rspec', :group => :development
+gem 'guard-rubocop', :group => :development
+gem 'rb-fsevent', :group => :development
+gem 'terminal-notifier-guard', :group => :development
+gem 'wirble', :group => :development
+# --DEVUP

data/Gemfile.lock

@@ -0,0 +1,118 @@
+PATH
+  remote: .
+  specs:
+    ice_cube_cron (0.0.1)
+      activesupport (>= 3.0.0)
+      ice_cube (= 0.13.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.4)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    ast (2.1.0)
+    astrolabe (1.3.1)
+      parser (~> 2.2)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    ffi (1.9.10)
+    formatador (0.2.5)
+    guard (2.13.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, <= 4.0)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.6.4)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    guard-rubocop (1.2.0)
+      guard (~> 2.0)
+      rubocop (~> 0.20)
+    guard-zeus (2.0.1)
+      guard (~> 2.0)
+      guard-compat (~> 1.1)
+      zeus (~> 0)
+    i18n (0.7.0)
+    ice_cube (0.13.0)
+    json (1.8.3)
+    listen (3.0.3)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.9)
+    method_source (0.8.2)
+    minitest (5.8.1)
+    nenv (0.2.0)
+    notiffany (0.0.8)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    parser (2.2.3.0)
+      ast (>= 1.1, < 3.0)
+    powerpack (0.1.1)
+    pry (0.10.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rainbow (2.0.0)
+    rake (10.4.2)
+    rb-fsevent (0.9.6)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    rubocop (0.34.2)
+      astrolabe (~> 1.3)
+      parser (>= 2.2.2.5, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.4)
+    ruby-progressbar (1.7.5)
+    shellany (0.0.1)
+    slop (3.6.0)
+    terminal-notifier-guard (1.6.4)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    wirble (0.1.3)
+    zeus (0.15.4)
+      method_source (>= 0.6.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  guard-rspec
+  guard-rubocop
+  guard-zeus
+  ice_cube_cron!
+  pry
+  rake
+  rb-fsevent
+  rspec
+  rubocop
+  terminal-notifier-guard
+  wirble
+
+BUNDLED WITH
+   1.10.6

data/Guardfile

@@ -0,0 +1,39 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ("."), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: "bundle exec rspec"
+#  * bundler binstubs: "bin/rspec"
+#  * spring: "bin/rspec" (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: "zeus rspec" (requires the server to be started separately)
+#  * "just" rspec: "bin/rspec"
+
+# , failed_mode: :focus
+
+group :red_green_refactor, :halt_on_fail => true do
+  guard :rspec, :cmd => 'rspec' do
+    watch('^spec/.+(_spec)')
+    watch('^lib/(.+)\.rb') { |m| "spec/lib\/#{m[1]}_spec.rb" }
+  end
+
+  guard :rubocop, :all_on_start => false do
+    watch(/.+\.rb$/)
+    watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
+  end
+end

data/LICENSE

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

data/README.md

@@ -0,0 +1,67 @@
+# ice_cube_cron
+
+Adds new methods to ice_cube to create schedules using standard cron expressions.
+
+## description
+
+**ice_cube** is a sold library for projecting and querying recurrence rules. **Cron** is _the_ standard for expressing recurrence rules. This gem will allow you to generate ice_cube schedules using standard cron expressions [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
+
+    gem install ice_cube_cron
+
+or add to Gemfile
+
+    gem "ice_cube_cron"
+
+## example
+
+Cron expression can be specified using a hash or a string in the format:
+```
+ # * * * * * *  command to execute
+ # │ │ │ │ │ │
+ # │ │ │ │ │ │
+ # │ │ │ │ │ └───── year (optional) (1970–2099)
+ # │ │ │ │ └───── day of week (0 - 6)
+ # │ │ │ └────────── month (1 - 12)
+ # │ │ └─────────────── day of month (1 - 31)
+ # │ └──────────────────── hour (0 - 23)
+ # └───────────────────────── min (0 - 59)
+```
+*[chart source](https://en.wikipedia.org/wiki/Cron)*
+
+
+```ruby
+# using cron expression string (not supported yet)
+schedule = ::IceCube::Schedule.from_cron(::Date.current, "* * * * 5")
+
+# using hash
+schedule = ::IceCube::Schedule.from_cron(::Date.current, :repeat_day => 5)
+
+schedule.occurrences_between(::Date.new(2015, 3, 5), ::Date.new(2015, 6, 5))
+# => [2015-03-05, 2015-04-05, 2015-06-05]
+```
+
+## 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.
+- Does not yet support all recurrence options. More coming.
+
+## todo
+- Add support for time options
+- Add support for string cron expressions

data/ice_cube_cron.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'ice_cube_cron/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'ice_cube_cron'
+  s.version     = IceCubeCron::VERSION
+  s.authors     = ['Matt Nichols']
+  s.email       = ['matt@nichols.name']
+  s.homepage    = 'https://github.com/mattnichols/ice_cube_cron'
+  s.summary     = 'Adds ability to create ice_cube schedules from cron expressions.'
+  s.description = 'Adds methods to ice_cube that creation of schedules using standard cron expressions.'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ['lib']
+
+  ##
+  # Dependencies
+  #
+  s.add_dependency 'ice_cube', '= 0.13.0'
+  s.add_dependency 'activesupport', '>= 3.0.0'
+
+  ##
+  # Development Dependencies
+  #
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rubocop'
+end

data/lib/ice_cube_cron/base.rb

@@ -0,0 +1,13 @@
+module IceCube
+  class << self
+    def from_cron(start_time, expression = {})
+      expression_parser = ::IceCubeCron::ExpressionParser.new(expression)
+      rule = ::IceCubeCron::RuleBuilder.new.build_rule(expression_parser)
+
+      schedule = ::IceCube::Schedule.new(::IceCubeCron::Util.sanitize_date_param(start_time))
+      schedule.add_recurrence_rule(rule)
+
+      schedule
+    end
+  end
+end

data/lib/ice_cube_cron/expression_parser.rb

@@ -0,0 +1,123 @@
+module IceCubeCron
+  class ExpressionParser
+    attr_accessor :expression_hash
+
+    def initialize(exp)
+      self.expression_hash = {
+        :repeat_interval => 1,
+        :repeat_year => nil,
+        :repeat_month => nil,
+        :repeat_day => nil,
+        :repeat_weekday => nil
+      }
+
+      if exp.is_a?(::Hash)
+        exp.each do |name, val|
+          send("#{name}=", val)
+        end
+      elsif exp.is_a?(::String)
+        fail ArgumentError, 'string cron expressions are not yet supported'
+      end
+    end
+
+    def [](val_name)
+      send(val_name)
+    end
+
+    def []=(val_name, new_val)
+      send("#{val_name}=", new_val)
+    end
+
+    def interval
+      expression_hash[:repeat_interval]
+    end
+    alias_method :repeat_interval, :interval
+
+    def interval=(val)
+      expression_hash[:repeat_interval] = sanitize_integer_param(val, 1)
+    end
+    alias_method :repeat_interval=, :interval=
+
+    def day
+      expression_hash[:repeat_day]
+    end
+    alias_method :repeat_day, :day
+
+    def day=(val)
+      expression_hash[:repeat_day] = sanitize_day_param(val)
+    end
+    alias_method :repeat_day=, :day=
+
+    def month
+      expression_hash[:repeat_month]
+    end
+    alias_method :repeat_month, :month
+
+    def month=(val)
+      expression_hash[:repeat_month] = sanitize_integer_array_param(val)
+    end
+    alias_method :repeat_month=, :month=
+
+    def year
+      expression_hash[:repeat_year]
+    end
+    alias_method :repeat_year, :year
+
+    def year=(val)
+      expression_hash[:repeat_year] = sanitize_integer_array_param(val)
+    end
+    alias_method :repeat_year=, :year=
+
+    def weekday
+      expression_hash[:repeat_weekday]
+    end
+    alias_method :repeat_weekday, :weekday
+
+    def weekday=(val)
+      expression_hash[:repeat_weekday] = sanitize_week_day_param(val)
+    end
+    alias_method :repeat_weekday=, :weekday=
+
+  private
+
+    def sanitize_integer_param(param, default = nil)
+      return default if param.blank?
+
+      param.to_i
+    end
+
+    def sanitize_day_param(param)
+      return nil if param.blank?
+      return param if param.is_a?(::Array)
+      return [param] if param.is_a?(::Integer)
+
+      param.to_s.split(',').map do |element|
+        next -1 if element == 'L'
+
+        element.to_i
+      end
+    end
+
+    def sanitize_week_day_param(param)
+      return nil if param.blank?
+      param.to_s.split(',').map do |element|
+        if element =~ /[0-9]+#[0-9]+/
+          parts = element.split('#')
+          { sanitize_integer_param(parts[0]) => sanitize_integer_array_param(parts[1]) }
+        elsif element =~ /[0-9]+L/
+          { sanitize_integer_param(element) => [-1] }
+        else
+          sanitize_integer_param(element)
+        end
+      end
+    end
+
+    def 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
+  end
+end

data/lib/ice_cube_cron/rule_builder.rb

@@ -0,0 +1,34 @@
+module IceCubeCron
+  class RuleBuilder
+    def build_rule(params)
+      rule = build_root_recurrence_rule(params)
+      rule = rule.month_of_year(*params[:month]) unless params[:month].blank?
+      rule = rule.day_of_month(*params[:day]) unless params[:day].blank?
+      rule = build_weekday_rule(rule, params)
+
+      rule
+    end
+
+    def build_weekday_rule(rule, params)
+      return rule.day_of_week(*params[:weekday]) if !params[:weekday].blank? && nth_day?(params[:weekday])
+      return rule.day(*params[:weekday]) unless params[:weekday].blank?
+
+      rule
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def build_root_recurrence_rule(params)
+      return ::IceCube::Rule.yearly(params[:interval]) unless params[:month].blank?
+      return ::IceCube::Rule.monthly(params[:interval]) if !params[:weekday].blank? && nth_day?(params[:weekday])
+      return ::IceCube::Rule.weekly(params[:interval]) unless params[:weekday].blank?
+
+      ::IceCube::Rule.monthly(params[:interval])
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def nth_day?(param)
+      return false if param.nil? || param.empty?
+      param[0].is_a?(::Hash)
+    end
+  end
+end

data/lib/ice_cube_cron/util.rb

@@ -0,0 +1,11 @@
+module IceCubeCron
+  module Util
+    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)
+      date = Time.at(date).utc if date.is_a?(::Integer)
+
+      date
+    end
+  end
+end

data/lib/ice_cube_cron/version.rb

@@ -0,0 +1,3 @@
+module IceCubeCron
+  VERSION = '0.0.1'
+end

data/lib/ice_cube_cron.rb

@@ -0,0 +1,10 @@
+require 'ice_cube'
+
+require 'active_support/core_ext/date'
+require 'active_support/core_ext/integer'
+
+require 'ice_cube_cron/version'
+require 'ice_cube_cron/util'
+require 'ice_cube_cron/rule_builder'
+require 'ice_cube_cron/expression_parser'
+require 'ice_cube_cron/base'

data/spec/lib/ice_cube_cron/base_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+describe ::IceCubeCron do
+  context 'repeat options' do
+    describe 'monthly' do
+      let(:ice_cube_model) { ::IceCube.from_cron(::Date.new(2015, 7, 1), :repeat_day => '1') }
+
+      it 'for same day' do
+        expect(ice_cube_model.occurrences_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.occurrences_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(:ice_cube_model) { ::IceCube.from_cron(::Date.new(2015, 7, 1), :repeat_day => '1,15') }
+
+      it 'for one month' do
+        expect(ice_cube_model.occurrences_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.occurrences_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
+        ::IceCube.from_cron(
+          ::Date.new(2015, 5, 1),
+          :repeat_day => '1',
+          :repeat_interval => '2'
+        )
+      end
+
+      it 'for one month' do
+        expect(ice_cube_model.occurrences_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.occurrences_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
+        ::IceCube.from_cron(
+          ::Date.new(2015, 7, 6),
+          :repeat_weekday => '1'
+        )
+      end
+
+      it 'for one week' do
+        expect(
+          ice_cube_model.occurrences_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.occurrences_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
+        ::IceCube.from_cron(
+          ::Date.new(2015, 7, 6),
+          :repeat_weekday => '1',
+          :repeat_interval => '2'
+        )
+      end
+
+      it 'for one week' do
+        expect(
+          ice_cube_model.occurrences_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.occurrences_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
+        ::IceCube.from_cron(
+          ::Date.new(2015, 1, 1),
+          :repeat_month => 2
+        )
+      end
+
+      it 'for one year' do
+        expect(ice_cube_model.occurrences_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.occurrences_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
+        ::IceCube.from_cron(
+          ::Date.new(2015, 1, 1),
+          :repeat_interval => 2,
+          :repeat_month => 2,
+          :repeat_day => 1
+        )
+      end
+
+      it 'for two years' do
+        expect(ice_cube_model.occurrences_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
+          ::IceCube.from_cron(
+            ::Date.new(2015, 1, 1),
+            :repeat_weekday => '5L'
+          )
+        end
+
+        it 'for one month' do
+          expect(ice_cube_model.occurrences_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
+          ::IceCube.from_cron(
+            ::Date.new(2015, 1, 1),
+            :repeat_weekday => '3L'
+          )
+        end
+
+        it 'for one month' do
+          expect(ice_cube_model.occurrences_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
+          ::IceCube.from_cron(
+            ::Date.new(2015, 1, 1),
+            :repeat_day => 'L'
+          )
+        end
+
+        it 'for one multiple months' do
+          expect(ice_cube_model.occurrences_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
+        ::IceCube.from_cron(
+          ::Date.new(2015, 1, 1),
+          :repeat_weekday => '1#2'
+        )
+      end
+
+      it 'for one month' do
+        expect(ice_cube_model.occurrences_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.occurrences_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
+    it 'handles ::DateTime as input' do
+      ice_cube_model = ::IceCube.from_cron(
+        ::DateTime.new(2015, 5, 1),
+        :repeat_day => '1',
+        :repeat_interval => '2'
+      )
+      expect(ice_cube_model.occurrences_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 = ::IceCube.from_cron(
+        1_430_438_400, # Fri, 01 May 2015 00:00:00 GMT
+        :repeat_day => '1',
+        :repeat_interval => '2'
+      )
+      expect(ice_cube_model.occurrences_between(::DateTime.new(2015, 7, 1), ::DateTime.new(2015, 7, 31))).to eq([::DateTime.new(2015, 7, 1)])
+    end
+  end
+end

data/spec/lib/ice_cube_cron/expression_parser_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe ::IceCubeCron::ExpressionParser do
+  let(:expression_parser) do
+    described_class.new(
+      :repeat_interval => 2,
+      :repeat_day => 3,
+      :repeat_month => 4,
+      :repeat_year => 1990,
+      :repeat_weekday => 0
+    )
+  end
+
+  describe 'parses ::Hash expression' do
+    describe 'repeat_interval' do
+      it '[]' do
+        expect(expression_parser[:repeat_interval]).to eq(2)
+      end
+
+      it '[]=' do
+        expression_parser[:repeat_interval] = 13
+        expect(expression_parser[:repeat_interval]).to eq(13)
+      end
+
+      it 'sanitizes' do
+        expression_parser[:repeat_interval] = 2
+        expect(expression_parser[:repeat_interval]).to eq(2)
+
+        expression_parser[:repeat_interval] = nil
+        expect(expression_parser[:repeat_interval]).to eq(1)
+
+        expression_parser[:repeat_interval] = '3'
+        expect(expression_parser[:repeat_interval]).to eq(3)
+      end
+    end
+
+    describe 'repeat_day' do
+      it '[]' do
+        expect(expression_parser[:repeat_day]).to eq([3])
+      end
+
+      it '[]=' do
+        expression_parser[:repeat_day] = 6
+        expect(expression_parser[:repeat_day]).to eq([6])
+      end
+
+      it 'sanitizes' do
+        expression_parser[:repeat_day] = 2
+        expect(expression_parser[:repeat_day]).to eq([2])
+
+        expression_parser[:repeat_day] = nil
+        expect(expression_parser[:repeat_day]).to eq(nil)
+
+        expression_parser[:repeat_day] = '3'
+        expect(expression_parser[:repeat_day]).to eq([3])
+      end
+
+      it 'should accept single day expression' do
+        expression_parser.repeat_day = '1'
+        expect(expression_parser.repeat_day).to eq([1])
+      end
+
+      it 'should accept series expression' do
+        expression_parser.repeat_day = '1,3'
+        expect(expression_parser.repeat_day).to eq([1, 3])
+      end
+
+      it 'should accept last day expression' do
+        expression_parser.repeat_day = 'L'
+        expect(expression_parser.repeat_day).to eq([-1])
+      end
+    end
+
+    describe 'repeat_month' do
+      it '[]' do
+        expect(expression_parser[:repeat_month]).to eq([4])
+      end
+
+      it '[]=' do
+        expression_parser[:repeat_month] = 11
+        expect(expression_parser[:repeat_month]).to eq([11])
+      end
+
+      it 'sanitizes' do
+        expression_parser[:repeat_month] = 2
+        expect(expression_parser[:repeat_month]).to eq([2])
+
+        expression_parser[:repeat_month] = nil
+        expect(expression_parser[:repeat_month]).to eq(nil)
+
+        expression_parser[:repeat_month] = '3'
+        expect(expression_parser[:repeat_month]).to eq([3])
+      end
+    end
+
+    describe 'repeat_year' do
+      it '[]' do
+        expect(expression_parser[:repeat_year]).to eq([1990])
+      end
+
+      it '[]=' do
+        expression_parser[:repeat_year] = 1994
+        expect(expression_parser[:repeat_year]).to eq([1994])
+      end
+
+      it 'sanitizes' do
+        expression_parser[:repeat_year] = 1992
+        expect(expression_parser[:repeat_year]).to eq([1992])
+
+        expression_parser[:repeat_year] = nil
+        expect(expression_parser[:repeat_year]).to eq(nil)
+
+        expression_parser[:repeat_year] = '2001'
+        expect(expression_parser[:repeat_year]).to eq([2001])
+      end
+    end
+
+    describe 'repeat_weekday' do
+      it '[]' do
+        expect(expression_parser[:repeat_weekday]).to eq([0])
+      end
+
+      it '[]=' do
+        expression_parser[:repeat_weekday] = 4
+        expect(expression_parser[:repeat_weekday]).to eq([4])
+      end
+
+      it 'sanitizes' do
+        expression_parser[:repeat_weekday] = 2
+        expect(expression_parser[:repeat_weekday]).to eq([2])
+
+        expression_parser[:repeat_weekday] = nil
+        expect(expression_parser[:repeat_weekday]).to eq(nil)
+
+        expression_parser[:repeat_weekday] = '3'
+        expect(expression_parser[:repeat_weekday]).to eq([3])
+      end
+
+      it 'should accept non-nth weekday expression' do
+        expression_parser.weekday = '1'
+        expect(expression_parser.weekday).to eq([1])
+      end
+
+      it 'should accept nth weekday expression' do
+        expression_parser.weekday = '1#3'
+        expect(expression_parser.weekday).to eq([{ 1 => [3] }])
+      end
+
+      it 'should accept last weekday expression' do
+        expression_parser.weekday = '1L'
+        expect(expression_parser.weekday).to eq([{ 1 => [-1] }])
+      end
+    end
+  end
+end

data/spec/lib/ice_cube_cron/rule_builder_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe ::IceCubeCron::RuleBuilder do
+  let(:expression) do
+    ::IceCubeCron::ExpressionParser.new({})
+  end
+
+  let(:rule_builder) { described_class.new }
+
+  describe 'builds correct root rule' do
+    it 'monthly' do
+      expression.day = 5
+      expect(rule_builder.build_rule(expression)).to be_a(IceCube::MonthlyRule)
+    end
+
+    it 'weekly' do
+      expression.weekday = 2
+      expect(rule_builder.build_rule(expression)).to be_a(IceCube::WeeklyRule)
+    end
+
+    it 'yearly' do
+      expression.month = 2
+      expect(rule_builder.build_rule(expression)).to be_a(IceCube::YearlyRule)
+    end
+  end
+
+  describe '#nth_day?' do
+    it 'should accept nil' do
+      expect(rule_builder.nth_day?(nil)).to be false
+    end
+
+    it 'should accept non-nth weekday expression' do
+      expect(rule_builder.nth_day?([1])).to be false
+    end
+
+    it 'should accept nth weekday expression' do
+      expect(rule_builder.nth_day?([{ 1 => [3] }])).to be true
+    end
+  end
+end

data/spec/lib/ice_cube_cron/util_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe ::IceCubeCron::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

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'ice_cube_cron'
+require 'pry'
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: ice_cube_cron
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Matt Nichols
+autorequire: 
+bindir: bin
+cert_chain: []
+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
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: pry
+  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: 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: 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'
+description: Adds methods to ice_cube that creation of schedules using standard cron
+  expressions.
+email:
+- matt@nichols.name
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE
+- README.md
+- ice_cube_cron.gemspec
+- lib/ice_cube_cron.rb
+- lib/ice_cube_cron/base.rb
+- lib/ice_cube_cron/expression_parser.rb
+- lib/ice_cube_cron/rule_builder.rb
+- lib/ice_cube_cron/util.rb
+- lib/ice_cube_cron/version.rb
+- spec/lib/ice_cube_cron/base_spec.rb
+- spec/lib/ice_cube_cron/expression_parser_spec.rb
+- spec/lib/ice_cube_cron/rule_builder_spec.rb
+- spec/lib/ice_cube_cron/util_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/mattnichols/ice_cube_cron
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Adds ability to create ice_cube schedules from cron expressions.
+test_files:
+- spec/lib/ice_cube_cron/base_spec.rb
+- spec/lib/ice_cube_cron/expression_parser_spec.rb
+- spec/lib/ice_cube_cron/rule_builder_spec.rb
+- spec/lib/ice_cube_cron/util_spec.rb
+- spec/spec_helper.rb