ice_cube_cron 0.0.5 → 1.0.0

data/spec/lib/ice_cube_cron/expression_parser_spec.rb

@@ -4,11 +4,13 @@ describe ::IceCubeCron::ExpressionParser do
   let(:expression) do
     described_class.new(
       nil,
-      :repeat_interval => 2,
-      :repeat_day => 3,
-      :repeat_month => 4,
-      :repeat_year => 1990,
-      :repeat_weekday => 0
+      :interval => 2,
+      :day_of_month => 3,
+      :month => 4,
+      :year => 1990,
+      :day_of_week => 0,
+      :hour => 5,
+      :minute => 6
     )
   end
 
@@ -18,49 +20,86 @@ describe ::IceCubeCron::ExpressionParser do
     # rubocop:enable Style/SymbolProc
     let(:expression) { described_class.new(expression_str) }
 
-    it '* * 2 * *' do
-      expect(expression.expression_hash[:repeat_interval]).to eq(1)
-      expect(expression.expression_hash[:repeat_year]).to eq(nil)
-      expect(expression.expression_hash[:repeat_month]).to eq(nil)
-      expect(expression.expression_hash[:repeat_day]).to eq([2])
-      expect(expression.expression_hash[:repeat_weekday]).to eq(nil)
+    it '1 * 2 * *' do
+      expect(expression.interval).to eq(1)
+      expect(expression.year).to eq(nil)
+      expect(expression.month).to eq(nil)
+      expect(expression.day).to eq([2])
+      expect(expression.day_of_week).to eq(nil)
+      expect(expression.hour).to eq(nil)
+      expect(expression.minute).to eq([1])
     end
 
-    it '* * 1,15 * *' do
-      expect(expression.expression_hash[:repeat_interval]).to eq(1)
-      expect(expression.expression_hash[:repeat_year]).to eq(nil)
-      expect(expression.expression_hash[:repeat_month]).to eq(nil)
-      expect(expression.expression_hash[:repeat_day]).to eq([1, 15])
-      expect(expression.expression_hash[:repeat_weekday]).to eq(nil)
+    it '* 12 1,15 * *' do
+      expect(expression.interval).to eq(1)
+      expect(expression.year).to eq(nil)
+      expect(expression.month).to eq(nil)
+      expect(expression.day_of_month).to eq([1, 15])
+      expect(expression.day_of_week).to eq(nil)
+      expect(expression.hour).to eq([12])
+      expect(expression.minute).to eq(nil)
     end
 
     it '* * 1 6,12 *' do
-      expect(expression.expression_hash[:repeat_interval]).to eq(1)
-      expect(expression.expression_hash[:repeat_year]).to eq(nil)
-      expect(expression.expression_hash[:repeat_month]).to eq([6, 12])
-      expect(expression.expression_hash[:repeat_day]).to eq([1])
-      expect(expression.expression_hash[:repeat_weekday]).to eq(nil)
+      expect(expression.interval).to eq(1)
+      expect(expression.year).to eq(nil)
+      expect(expression.month).to eq([6, 12])
+      expect(expression.day_of_month).to eq([1])
+      expect(expression.day_of_week).to eq(nil)
+      expect(expression.hour).to eq(nil)
+      expect(expression.minute).to eq(nil)
     end
 
     it '* * 1 6 * 2015' do
-      expect(expression.expression_hash[:repeat_interval]).to eq(1)
-      expect(expression.expression_hash[:repeat_year]).to eq([2015])
-      expect(expression.expression_hash[:repeat_month]).to eq([6])
-      expect(expression.expression_hash[:repeat_day]).to eq([1])
-      expect(expression.expression_hash[:repeat_weekday]).to eq(nil)
+      expect(expression.interval).to eq(1)
+      expect(expression.year).to eq([2015])
+      expect(expression.month).to eq([6])
+      expect(expression.day_of_month).to eq([1])
+      expect(expression.day_of_week).to eq(nil)
+      expect(expression.hour).to eq(nil)
+      expect(expression.minute).to eq(nil)
     end
 
     it '* * * 6 1L *' do
-      expect(expression.expression_hash[:repeat_interval]).to eq(1)
-      expect(expression.expression_hash[:repeat_year]).to eq(nil)
-      expect(expression.expression_hash[:repeat_month]).to eq([6])
-      expect(expression.expression_hash[:repeat_day]).to eq(nil)
-      expect(expression.expression_hash[:repeat_weekday]).to eq([1 => [-1]])
+      expect(expression.interval).to eq(1)
+      expect(expression.year).to eq(nil)
+      expect(expression.month).to eq([6])
+      expect(expression.day_of_month).to eq(nil)
+      expect(expression.day_of_week).to eq([1 => [-1]])
+      expect(expression.hour).to eq(nil)
+      expect(expression.minute).to eq(nil)
+    end
+
+    it '*/5 * * * * *' do
+      expect(expression.interval).to eq(5)
+      expect(expression.year).to eq(nil)
+      expect(expression.month).to eq(nil)
+      expect(expression.day_of_month).to eq(nil)
+      expect(expression.day_of_week).to eq(nil)
+      expect(expression.hour).to eq(nil)
+      expect(expression.minute).to eq(nil)
+    end
+
+    it '1 */12 * * * *' do
+      expect(expression.interval).to eq(12)
+      expect(expression.year).to eq(nil)
+      expect(expression.month).to eq(nil)
+      expect(expression.day_of_month).to eq(nil)
+      expect(expression.day_of_week).to eq(nil)
+      expect(expression.hour).to eq(nil)
+      expect(expression.minute).to eq([1])
+    end
+
+    # Only one interval is supported
+    it '*/1 */12 * * * *' do
+      expect(expression.interval).to eq(12)
+      expect(expression.hour).to eq(nil)
+      expect(expression.minute).to eq(nil)
     end
   end
 
   describe 'parses ::Hash expression' do
-    describe 'repeat_interval' do
+    describe 'interval' do
       it '[]' do
         expect(expression.interval).to eq(2)
       end
@@ -82,49 +121,123 @@ describe ::IceCubeCron::ExpressionParser do
       end
     end
 
-    describe 'repeat_day' do
+    describe 'minute' do
       it '[]' do
-        expect(expression.day).to eq([3])
+        expect(expression.minute).to eq([6])
       end
 
       it '[]=' do
-        expression.day = 6
-        expect(expression.day).to eq([6])
+        expression.minute = 6
+        expect(expression.minute).to eq([6])
       end
 
       it 'sanitizes' do
-        expression.day = 2
-        expect(expression.day).to eq([2])
+        expression.minute = 2
+        expect(expression.minute).to eq([2])
 
-        expression.day = nil
-        expect(expression.day).to eq(nil)
+        expression.minute = nil
+        expect(expression.minute).to eq(nil)
 
-        expression.day = '3'
-        expect(expression.day).to eq([3])
+        expression.minute = '3'
+        expect(expression.minute).to eq([3])
+      end
+
+      it 'should accept single minute expression' do
+        expression.minute = '1'
+        expect(expression.minute).to eq([1])
+      end
+
+      it 'should accept series expression' do
+        expression.minute = '1,3'
+        expect(expression.minute).to eq([1, 3])
+      end
+
+      it 'should accept range expression' do
+        expression.minute = '1-3'
+        expect(expression.minute).to eq([1, 2, 3])
+      end
+    end
+
+    describe 'hour' do
+      it '[]' do
+        expect(expression.hour).to eq([5])
+      end
+
+      it '[]=' do
+        expression.hour = 6
+        expect(expression.hour).to eq([6])
+      end
+
+      it 'sanitizes' do
+        expression.hour = 2
+        expect(expression.hour).to eq([2])
+
+        expression.hour = nil
+        expect(expression.hour).to eq(nil)
+
+        expression.hour = '3'
+        expect(expression.hour).to eq([3])
+      end
+
+      it 'should accept single hour expression' do
+        expression.hour = '1'
+        expect(expression.hour).to eq([1])
+      end
+
+      it 'should accept series expression' do
+        expression.hour = '1,3'
+        expect(expression.hour).to eq([1, 3])
+      end
+
+      it 'should accept range expression' do
+        expression.hour = '1-3'
+        expect(expression.hour).to eq([1, 2, 3])
+      end
+    end
+
+    describe 'day_of_month' do
+      it '[]' do
+        expect(expression.day_of_month).to eq([3])
+      end
+
+      it '[]=' do
+        expression.day_of_month = 6
+        expect(expression.day_of_month).to eq([6])
+      end
+
+      it 'sanitizes' do
+        expression.day_of_month = 2
+        expect(expression.day_of_month).to eq([2])
+
+        expression.day_of_month = nil
+        expect(expression.day_of_month).to eq(nil)
+
+        expression.day_of_month = '3'
+        expect(expression.day_of_month).to eq([3])
       end
 
       it 'should accept single day expression' do
-        expression.day = '1'
-        expect(expression.day).to eq([1])
+        expression.day_of_month = '1'
+        expect(expression.day_of_month).to eq([1])
       end
 
       it 'should accept series expression' do
-        expression.day = '1,3'
-        expect(expression.day).to eq([1, 3])
+        expression.day_of_month = '1,3'
+        expect(expression.day_of_month).to eq([1, 3])
       end
 
       it 'should accept range expression' do
-        expression.day = '1-3'
-        expect(expression.day).to eq([1, 2, 3])
+        expression.day_of_month = '1-3'
+        expect(expression.day_of_month).to eq([1, 2, 3])
       end
 
       it 'should accept last day expression' do
-        expression.day = 'L'
-        expect(expression.day).to eq([-1])
+        expression.day_of_month = 'L'
+        expect(expression.day_of_month).to eq([-1])
       end
     end
 
-    describe 'repeat_month' do
+    describe 'month' do
       it '[]' do
         expect(expression.month).to eq([4])
       end
@@ -146,7 +259,7 @@ describe ::IceCubeCron::ExpressionParser do
       end
     end
 
-    describe 'repeat_year' do
+    describe 'year' do
       it '[]' do
         expect(expression.year).to eq([1990])
       end
@@ -168,41 +281,49 @@ describe ::IceCubeCron::ExpressionParser do
       end
     end
 
-    describe 'repeat_weekday' do
+    describe 'day_of_week' do
       it '[]' do
-        expect(expression.weekday).to eq([0])
+        expect(expression.day_of_week).to eq([0])
       end
 
       it '[]=' do
-        expression.weekday = 4
-        expect(expression.weekday).to eq([4])
+        expression.day_of_week = 4
+        expect(expression.day_of_week).to eq([4])
       end
 
       it 'sanitizes' do
-        expression.weekday = 2
-        expect(expression.weekday).to eq([2])
+        expression.day_of_week = 2
+        expect(expression.day_of_week).to eq([2])
 
-        expression.weekday = nil
-        expect(expression.weekday).to eq(nil)
+        expression.day_of_week = nil
+        expect(expression.day_of_week).to eq(nil)
 
-        expression.weekday = '3'
-        expect(expression.weekday).to eq([3])
+        expression.day_of_week = '3'
+        expect(expression.day_of_week).to eq([3])
       end
 
       it 'should accept non-nth weekday expression' do
-        expression.weekday = '1'
-        expect(expression.weekday).to eq([1])
+        expression.day_of_week = '1'
+        expect(expression.day_of_week).to eq([1])
       end
 
       it 'should accept nth weekday expression' do
-        expression.weekday = '1#3'
-        expect(expression.weekday).to eq([{ 1 => [3] }])
+        expression.day_of_week = '1#3'
+        expect(expression.day_of_week).to eq([{ 1 => [3] }])
       end
 
       it 'should accept last weekday expression' do
-        expression.weekday = '1L'
-        expect(expression.weekday).to eq([{ 1 => [-1] }])
+        expression.day_of_week = '1L'
+        expect(expression.day_of_week).to eq([{ 1 => [-1] }])
       end
     end
   end
+
+  describe 'invalid parameters' do
+    it 'should raise helpful error' do
+      expect do
+        described_class.new(:invalid_param => 1)
+      end.to raise_error(ArgumentError)
+    end
+  end
 end

data/spec/lib/ice_cube_cron/rule_builder_spec.rb

@@ -8,25 +8,117 @@ describe ::IceCubeCron::RuleBuilder do
   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)
+    # rubocop:disable Style/SymbolProc
+    let(:expression_str) { |example| example.description }
+    # rubocop:enable Style/SymbolProc
+    let(:expression) { ::IceCubeCron::ExpressionParser.new(expression_str) }
+    let(:rule) { rule_builder.build_rule(expression) }
+
+    context 'minutely' do
+      it '* * * * *' do
+        expect(rule).to be_a(IceCube::MinutelyRule)
+      end
+
+      it '* 1 1 1 1 2015' do
+        expect(rule).to be_a(IceCube::MinutelyRule)
+      end
     end
 
-    it 'weekly' do
-      expression.weekday = 2
-      expect(rule_builder.build_rule(expression)).to be_a(IceCube::WeeklyRule)
+    context 'hourly' do
+      it '1 * * * *' do
+        expect(rule).to be_a(IceCube::HourlyRule)
+      end
+
+      it '1 * 1 1 1 2015' do
+        expect(rule).to be_a(IceCube::HourlyRule)
+      end
     end
 
-    it 'monthly (last week day of month)' do
-      expression.weekday = '2L'
-      expect(rule_builder.build_rule(expression)).to be_a(IceCube::MonthlyRule)
+    context 'daily' do
+      it '1 2 * * *' do
+        expect(rule).to be_a(IceCube::DailyRule)
+      end
+
+      it '1 2 * 1 * 2015' do
+        expect(rule).to be_a(IceCube::DailyRule)
+      end
     end
 
-    it 'yearly' do
-      expression.month = 2
-      expect(rule_builder.build_rule(expression)).to be_a(IceCube::YearlyRule)
+    context 'monthly' do
+      it '0 0 1 * *' do
+        expect(rule).to be_a(IceCube::MonthlyRule)
+      end
+
+      it '1 2 1 * * 2015' do
+        expect(rule).to be_a(IceCube::MonthlyRule)
+      end
+
+      it '1 2 1 * * 2015' do
+        expect(rule).to be_a(IceCube::MonthlyRule)
+      end
+
+      it '1 2 * * 1L 2015' do
+        expect(rule).to be_a(IceCube::MonthlyRule)
+      end
     end
+
+    context 'weekly' do
+      it '0 0 * * 1' do
+        expect(rule).to be_a(IceCube::WeeklyRule)
+      end
+
+      it '1 2 * * 1 2015' do
+        expect(rule).to be_a(IceCube::WeeklyRule)
+      end
+    end
+
+    context 'yearly' do
+      it '0 0 1 1 *' do
+        expect(rule).to be_a(IceCube::YearlyRule)
+      end
+
+      it '1 2 1 1 * 2015' do
+        expect(rule).to be_a(IceCube::YearlyRule)
+      end
+    end
+
+    # it '1 * 2 * *' do
+    #   expect(rule).to be_a(IceCube::MonthlyRule)
+    # end
+
+    # it '1 2 2 * *' do
+    #   expect(rule).to be_a(IceCube::MonthlyRule)
+    # end
+
+    # 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 'monthly (last week day of month)' do
+    #   expression.weekday = '2L'
+    #   expect(rule_builder.build_rule(expression)).to be_a(IceCube::MonthlyRule)
+    # end
+
+    # it 'yearly' do
+    #   expression.month = 2
+    #   expect(rule_builder.build_rule(expression)).to be_a(IceCube::YearlyRule)
+    # end
+
+    # it 'daily' do
+    #   expression.hour = 2
+    #   expect(rule_builder.build_rule(expression)).to be_a(IceCube::DailyRule)
+    # end
+
+    # it 'hourly' do
+    #   expression.minute = 2
+    #   expect(rule_builder.build_rule(expression)).to be_a(IceCube::HourlyRule)
+    # end
   end
 
   describe '#nth_day?' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ice_cube_cron
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  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-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ice_cube
@@ -107,7 +107,6 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - Gemfile
-- Gemfile.lock
 - Guardfile
 - LICENSE
 - README.md

data/Gemfile.lock

@@ -1,72 +0,0 @@
-PATH
-  remote: .
-  specs:
-    ice_cube_cron (0.0.4)
-      activesupport (~> 4)
-      ice_cube (~> 0.13)
-
-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)
-    i18n (0.7.0)
-    ice_cube (0.13.0)
-    json (1.8.3)
-    method_source (0.8.2)
-    minitest (5.8.2)
-    parser (2.2.3.0)
-      ast (>= 1.1, < 3.0)
-    powerpack (0.1.1)
-    pry (0.10.3)
-      coderay (~> 1.1.0)
-      method_source (~> 0.8.1)
-      slop (~> 3.4)
-    rainbow (2.0.0)
-    rake (10.4.2)
-    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)
-    slop (3.6.0)
-    thread_safe (0.3.5)
-    tzinfo (1.2.2)
-      thread_safe (~> 0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  ice_cube_cron!
-  pry (~> 0)
-  rake (~> 10)
-  rspec (~> 3.3)
-  rubocop (~> 0.34)
-
-BUNDLED WITH
-   1.10.6