ice_t 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 43afa790b32508abdc490d1390c56a5411c944dc
+  data.tar.gz: 2847c139721b59a32e3041a1b3acacc54df70684
+SHA512:
+  metadata.gz: 994528d6ea3d8c9c487f2df182a3a2cc9a1449bf71dd218a0465a32227ae4b737e0685689be90b2ce7eb4a4a0544cb93591e38ea9d2271dc653f3164c75c2c94
+  data.tar.gz: 0db1cbe1e52a19b847f6d6c89cb67321457e4f1f8112a0ceabc4ccaa4adfdf68c677a0fbe123a8f8885788555910688e3e36cdcf36659e8b40c520addccb60bb

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ice_t.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,12 @@
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml|slim)$})     { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Christian Nennemann
+
+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/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Christian Nennemann
+
+MIT License
+
+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,37 @@
+# IceT
+
+[![Code Climate](https://codeclimate.com/github/XORwell/ice_t.png)](https://codeclimate.com/github/XORwell/ice_t)
+[![Build Status](https://travis-ci.org/XORwell/ice_t.png)](https://travis-ci.org/XORwell/ice_t)
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ice_t'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ice_t
+
+## Usage
+
+TODO: Write usage instructions here
+
+
+## Tipps
+
+	### Sorting rules:
+
+	[r2,r1,r3].sort.collect(&:interval) 
+
+	### Comparing comparing:
+
+	daily(1) < daily(2)
+
+	r2.between?(r1, r3)

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+task :default => :spec
+RSpec::Core::RakeTask.new

data/ice_t.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ice_t/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ice_t"
+  spec.version       = IceT::VERSION
+  spec.authors       = ["Christian Nennemann"]
+  spec.email         = ["christian.nennemann@gmail.com"]
+  spec.description   = %q{IceT is a ruby library for handling repeated events}
+  spec.summary       = %q{Ruby Time Recurrence}
+  spec.homepage      = "https://github.com/XORwell/IceT"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", ">= 4.0.0"
+  #spec.add_dependency "i18n", ">= 0.6.5"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.13"
+  spec.add_development_dependency "turnip"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+
+end

data/lib/ice_t.rb

@@ -0,0 +1,21 @@
+require "ice_t/version"
+
+# TODO: be more specific instead including all..
+require 'active_support/all'
+
+
+module IceT
+  I18n.load_path += Dir[File.expand_path('../locales/*{rb,yml}', __FILE__)]
+
+  require 'ice_t/exceptions'
+
+  require 'ice_t/time_helper'
+  
+  require 'ice_t/conversions'
+  require 'ice_t/rule'
+  require 'ice_t/schedule'
+
+  # module Rule
+  #   autoload :Repository, 'ice_t/rule/repository'
+  # end
+end

data/lib/ice_t/conversions.rb

@@ -0,0 +1,37 @@
+module IceT
+  module Conversions
+    module Schedule
+      def from_json(json_string)
+        data = ActiveSupport::JSON.decode(json_string).symbolize_keys
+        
+        options = {
+          start_time: data[:start_time].to_time,
+          end_time: data[:end_time].to_time
+        }
+        schedule = self.new(options)
+
+        data[:rules]["rules"].each{ |rule|
+          rule_class = rule['export_class_name']
+          interval = rule['interval'].to_i
+          at = rule['at']  
+          init = if at.nil?
+                   rule_class + ".new(#{interval})"
+                 else
+                   rule_class + ".new(#{interval}, '#{at}')"
+                 end 
+          obj_rule = eval(init)
+          schedule.add_rule(obj_rule)
+        }
+        
+        schedule
+      end   
+
+
+      def from_yaml(yaml_string)
+        schedule = YAML::load(yaml_string)
+        return schedule if schedule.is_a?(IceT::Schedule)
+      end
+
+    end
+  end
+end

data/lib/ice_t/exceptions.rb

@@ -0,0 +1,3 @@
+module IceT  
+  class DuplicateRuleException < StandardError; end
+end

data/lib/ice_t/rule.rb

@@ -0,0 +1,13 @@
+module IceT
+  module Rule
+  end
+end
+
+require 'ice_t/rule/base'
+require 'ice_t/rule/repository'
+require 'ice_t/rule/minutely'
+require 'ice_t/rule/hourly'
+require 'ice_t/rule/daily'
+require 'ice_t/rule/monthly'
+require 'ice_t/rule/yearly'
+

data/lib/ice_t/rule/base.rb

@@ -0,0 +1,69 @@
+module IceT
+  module Rule
+    class Base
+
+      class << self
+        include Comparable
+        def <=>(other)
+          self.to_i <=> other.to_i
+        end
+      end
+
+      attr_reader :interval
+      attr_reader :at
+
+      def initialize(interval = 1, at_str = nil)
+        raise ArgumentError.new('Positive integer required') if interval.nil? ||
+                                                                interval.to_i < 1 ||
+                                                                interval % 1 != 0
+        @interval = interval
+        @at = at_str
+        @export_class_name = self.class.name
+        self.at = at_str unless @at.nil?
+      end
+
+      # set time information
+      def at=(str)
+        return if str.nil?
+        if Time.parse(str.to_s)
+          @at = str.to_s
+        end
+      end
+
+      include Comparable
+      def <=>(other)
+        case
+        when self.class == other.class &&
+             self.interval == other.interval
+             0
+        when self.class == other.class &&
+             self.interval < other.interval
+             -1 
+        when self.class == other.class &&
+             self.interval > other.interval
+             +1             
+        when self.class.to_i < other.class.to_i
+             -1
+        when self.class.to_i > other.class.to_i
+             +1
+        else
+          nil
+        end
+      end
+
+      def occurrences(start_time, end_time)
+        diff = IceT::TimeHelper.diff_by_unit(start_time, end_time, self.class.unit)
+        (1..diff).step(self.interval).map { |i|
+          start_time.advance(self.class.unit => i)
+        }
+      end
+
+      # private
+      # def at_adjusted_time(time)
+      #   unless @at.nil?
+      #     t = Time.parse(@at)
+      #   end
+      # end
+    end
+  end
+end

data/lib/ice_t/rule/daily.rb

@@ -0,0 +1,17 @@
+module IceT
+  module Rule
+    class Daily < Base
+      class << self
+        def to_i; 1.day.to_i end
+        def unit; :days end
+      end
+      
+      def to_s
+        word = (@interval.eql?(2))? 'zweiten' : @interval
+        # "jeden #{@interval} tage"
+        "jeden #{word} tag"
+      end
+
+    end
+  end
+end

data/lib/ice_t/rule/hourly.rb

@@ -0,0 +1,10 @@
+module IceT
+  module Rule
+    class Hourly < Base
+      class << self
+        def to_i; 1.hour.to_i end
+        def unit; :hours end
+      end
+    end
+  end
+end

data/lib/ice_t/rule/minutely.rb

@@ -0,0 +1,10 @@
+module IceT
+  module Rule
+    class Minutely < Base
+      class << self
+        def to_i; 1.minute.to_i end
+        def unit; :minutes end
+      end
+    end
+  end
+end

data/lib/ice_t/rule/monthly.rb

@@ -0,0 +1,10 @@
+module IceT
+  module Rule
+    class Monthly < Base
+      class << self
+        def to_i; 1.month.to_i end  
+        def unit; :months end      
+      end      
+    end
+  end
+end

data/lib/ice_t/rule/repository.rb

@@ -0,0 +1,25 @@
+require 'forwardable'
+
+module IceT
+  module Rule
+    class Repository
+      extend Forwardable
+      def_delegators :@rules, :empty?, :size, :first, :last, :collect
+
+      attr_reader :rules
+
+      def initialize
+        @rules = []      
+      end
+
+      def add(rule)
+        @rules << rule unless rule.nil?
+      end
+
+      def remove(rule)
+        @rules.delete(rule)
+      end
+
+    end    
+  end
+end

data/lib/ice_t/rule/yearly.rb

@@ -0,0 +1,10 @@
+module IceT
+  module Rule
+    class Yearly < Base
+      class << self
+        def to_i; 1.year.to_i end
+        def unit; :years end
+      end
+    end
+  end
+end

data/lib/ice_t/schedule.rb

@@ -0,0 +1,39 @@
+require 'forwardable'
+
+module IceT
+  class Schedule
+    
+    extend Forwardable    
+    def_delegator :@rules, :add, :add_rule
+    def_delegator :@rules, :remove, :remove_rule
+    def_delegator :@rules, :rules, :rules
+
+    extend IceT::Conversions::Schedule
+
+    attr_reader :start_time
+    attr_reader :end_time
+
+    def initialize(opts={})
+      opts = {
+        start_time: nil,
+        end_time: nil
+      }.merge(opts)
+      @start_time = opts[:start_time]
+      @end_time   = opts[:end_time]
+
+      @rules = IceT::Rule::Repository.new
+    end
+    
+    def occurrences
+      return [] if @rules.empty?
+      
+      # TODO: better error message      
+      fail('this needs start_time and end_time') if @start_time.nil? && @end_time.nil?
+
+      @rules.collect{ |rule|
+        rule.occurrences(@start_time, @end_time)
+      }.flatten
+    end
+
+  end
+end

data/lib/ice_t/time_helper.rb

@@ -0,0 +1,16 @@
+module IceT
+  module TimeHelper
+    module_function
+    #
+    # Returns diff of two date by given unit
+    # @param Time start_time
+    # @param Time end_time
+    # @param Symbol unit
+    # @param Boolean round 
+    # @return Integer|Float diff
+    def diff_by_unit(start_time, end_time, unit = :days, round = true)
+      diff = ((end_time - start_time) / eval("1.#{unit}"))
+      diff = (round) ? diff.round : diff
+    end
+  end
+end

data/lib/ice_t/version.rb

@@ -0,0 +1,3 @@
+module IceT
+  VERSION = "0.0.1"
+end

data/lib/locales/en.yml

@@ -0,0 +1,3 @@
+en:
+  ice_t:
+    hello: world

data/spec/exceptions_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+# describe IceT::Exceptions do 
+#   describe IceT::Exceptions::DuplicateRuleException do 
+#     context 'RuleRepository' do
+#       let(:r1) { IceT::Rule.daily(1) }
+#       # let(:r2) { IceT::Rule.daily(2) }
+      
+#     end
+#   end
+# end

data/spec/rules/base_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe IceT::Rule::Base do
+
+  describe '.new' do
+    describe 'param: interval' do
+      context 'when valid' do
+        it { expect{subject.class.new(1)}.not_to raise_error }
+        it { expect{subject.class.new()}.not_to raise_error }
+      end
+      context 'when invalid' do
+        it { expect{subject.class.new(-1)}.to raise_error }
+        it { expect{subject.class.new(1.2)}.to raise_error }
+        it { expect{subject.class.new("a")}.to raise_error }
+      end  
+    end
+
+    describe 'param: at' do
+      context 'when valid' do
+        it { expect{subject.class.new(1, "4pm")}.not_to raise_error }
+        it { expect{subject.class.new(1, nil)}.not_to raise_error }
+      end
+      context 'when invalid' do
+        it { expect{subject.class.new(1, "")}.to raise_error }
+        it { expect{subject.class.new(1, -1)}.to raise_error }
+        it { expect{subject.class.new(1, "a")}.to raise_error }
+      end
+    end
+  end  
+
+  context 'respond_to?' do
+    operators = ['==', '<', '>', '<=', '>=']
+    operators.each{ |operator|
+      describe operator do
+        it { expect(subject.class.new.respond_to?(operator.to_sym)).to be_true }  
+      end
+    }
+  end
+
+end

data/spec/rules/daily_rule_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe IceT::Rule::Daily do
+  let(:klass) { IceT::Rule::Daily }
+  it_behaves_like "a rule"
+end

data/spec/rules/hourly_rule_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe IceT::Rule::Hourly do
+  let(:klass) { IceT::Rule::Hourly }
+  it_behaves_like "a rule"
+end

data/spec/rules/minutely_rule_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe IceT::Rule::Minutely do
+  let(:klass) { IceT::Rule::Minutely }
+  it_behaves_like "a rule"
+end

data/spec/rules/monthly_rule_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe IceT::Rule::Monthly do
+
+  let(:klass) { IceT::Rule::Monthly }
+  it_behaves_like "a rule"
+
+  let!(:interval) { 1 }
+  let!(:start_time) { 1.year.ago }
+  let!(:end_time) { Time.now }
+  let(:rule) { IceT::Rule::Monthly.new(interval) }
+
+
+  describe "#occurrences" do
+    
+    subject { rule.occurrences(start_time, end_time) }
+
+    it "returns an array" do
+      expect(subject).to be_an(Array)
+    end
+
+    context "one year ago until now" do
+      it "returns an array with 12 elements" do
+        expect(subject.size).to eql(12) 
+      end
+      it "contains end_time as last element" do
+        expect(subject.last.to_date).to eql(end_time.to_date)
+      end
+    end
+
+  end
+  
+end

data/spec/rules/rules_repository_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe IceT::Rule::Repository do
+  let(:repo) { IceT::Rule::Repository.new }
+  let!(:rule_01) { IceT::Rule::Daily.new(1) }
+  let!(:rule_02) { IceT::Rule::Daily.new(2) }
+  let!(:rule_03) { IceT::Rule::Daily.new(3) }
+
+  describe '#rules' do
+    it "returns an array" do      
+      expect(repo.rules).to be_an(Array)
+    end
+  end
+
+  describe '#add' do
+    it "adds a rule" do
+      repo.add(rule_01)
+      expect(repo.rules.size).to eql(1)
+    end
+  end
+
+  describe '#remove' do
+    before (:each) { 
+      repo.add(rule_01) 
+      repo.add(rule_03) 
+      repo.add(rule_02)   
+    }
+
+    it "removes a rule" do
+      repo.remove(rule_02)
+      expect(repo.rules.last).to eql(rule_03)
+    end
+  end
+end

data/spec/rules/yearly_rule_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe IceT::Rule::Yearly do
+  let(:klass) { IceT::Rule::Yearly }
+  it_behaves_like "a rule"
+end

data/spec/schedule_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe IceT::Schedule do 
+  let!(:start_time) { Time.now }
+  let!(:end_time) { Time.now + 2.months }
+  let!(:schedule) { IceT::Schedule.new(start_time: start_time, end_time: end_time) }
+  let!(:daily_rule) { IceT::Rule::Daily.new(1) }
+  let!(:monthly_rule) { IceT::Rule::Monthly.new(1) }
+  let(:repo) { schedule.instance_variable_get(:@rules) }
+
+  describe '#add_rule' do
+    it "delegates to repository.add" do
+      expect(repo).to receive(:add).with(daily_rule)
+      schedule.add_rule(daily_rule)
+    end
+  end
+
+  describe '#remove_rule' do
+    it "delegates to repository.remove" do
+      expect(repo).to receive(:remove).with(daily_rule)
+      schedule.remove_rule(daily_rule)
+    end
+  end
+
+  describe '#rules' do
+    it "delegates to repository.rules" do
+      expect(repo).to receive(:rules)
+      schedule.rules
+    end
+  end
+
+  describe '#to_json' do
+    pending
+  end
+  
+  describe '#to_yaml' do
+    pending
+  end
+
+  describe '::from_json' do
+    context "the created object" do
+      before do
+        schedule.add_rule(daily_rule)
+        schedule.add_rule(monthly_rule)      
+        schedule.add_rule(IceT::Rule::Daily.new(12, "4pm"))      
+      end
+      let(:json) { schedule.to_json }
+      let(:object) { IceT::Schedule.from_json(json) }
+
+      it "is a Schedule" do
+        expect(object).to be_an(IceT::Schedule)
+      end
+      it "contains the same rules as before" do
+        expect(object.rules.map(&:to_json)).to eql(schedule.rules.map(&:to_json))
+      end
+
+      [:start_time, :end_time].each { |time|
+        it "does have the same #{time} as before" do
+          expect(object.send(time).to_i).to eql(eval("#{time}").to_i)
+        end
+      }
+
+    end
+  end
+  
+  describe '::from_yaml' do
+    pending
+  end
+
+end 

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'bundler/setup'
+# require 'active_support/all'
+
+require 'ice_t'
+
+Dir.glob(File.expand_path("spec/support/**/*.rb")).each{ |f| require f }
+
+
+RSpec.configure do |config|
+  config.color_enabled = true
+
+  config.tty = true
+
+  config.formatter = :documentation # :progress, :html, :textmate
+end

data/spec/support/shared_examples/rule_example.rb

@@ -0,0 +1,92 @@
+shared_examples 'a rule' do  
+  
+  describe '::to_i' do
+    it { expect(klass).to respond_to(:to_i) }
+  end
+  describe '::unit' do
+    it { expect(klass).to respond_to(:unit) }
+  end
+
+  describe '#occurrences' do
+    it { expect(klass.new).to respond_to(:occurrences) }
+  end
+
+  describe '::from_json' do
+    pending
+    #it { expect(klass).to respond_to(:from_json) }    
+  end
+
+  describe '::from_yaml' do
+    pending
+    #it { expect(klass).to respond_to(:from_yaml) }    
+  end
+
+  describe '#to_json' do
+    it { expect(klass.new).to respond_to(:to_json) }
+  end
+
+  describe '#to_yaml' do
+    it { expect(klass.new).to respond_to(:to_yaml) }
+  end
+
+  describe '#@at' do
+    it {expect(klass.new(1, "4pm").at).to eql("4pm")}
+  end
+
+
+  describe 'comparison' do
+    classes = IceT::Rule::Base.descendants.sort
+    classes.each_with_index { | obj, i |
+      classes.each_with_index { | other, j |
+        case 
+        when i == j
+          context 'on class level' do
+            it "#{obj} == #{other}" do
+              expect(obj==other).to be_true
+            end
+          end
+          context 'on instance level' do
+            it "#{obj}.new(1) == #{other}.new(1)" do
+              expect(obj.new(1) == other.new(1)).to be_true
+            end
+            it "#{obj}.new(1) < #{other}.new(2)" do
+              expect(obj.new(1) < other.new(2)).to be_true
+            end
+            it "#{obj}.new(2) > #{other}.new(1)" do
+              expect(obj.new(2) > other.new(1)).to be_true
+            end
+            it "#{obj}.new(1) <= #{other}.new(1)" do
+              expect(obj.new(1) <= other.new(1)).to be_true
+            end
+            it "#{obj}.new(1) >= #{other}.new(1)" do
+              expect(obj.new(1) >= other.new(1)).to be_true
+            end            
+          end
+        when i > j
+          context 'on class level' do
+            it "#{obj} > #{other}" do
+              expect(obj > other).to be_true
+            end
+          end
+          context 'on instance level' do
+            it "#{obj}.new(1) > #{other}.new(1)" do
+              expect(obj.new(1) > other.new(1)).to be_true
+            end
+          end
+        when i < j
+          context 'on class level' do
+            it "#{obj} < #{other}" do
+              expect(obj < other).to be_true
+            end            
+          end
+          context 'on instance level' do
+            it "#{obj}.new(1) < #{other}.new(1)" do
+              expect(obj.new(1) < other.new(1)).to be_true
+            end            
+          end
+        end
+      }        
+    }
+  end
+
+end

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification
+name: ice_t
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Christian Nennemann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: turnip
+  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
+  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'
+description: IceT is a ruby library for handling repeated events
+email:
+- christian.nennemann@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- Guardfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- ice_t.gemspec
+- lib/ice_t.rb
+- lib/ice_t/conversions.rb
+- lib/ice_t/exceptions.rb
+- lib/ice_t/rule.rb
+- lib/ice_t/rule/base.rb
+- lib/ice_t/rule/daily.rb
+- lib/ice_t/rule/hourly.rb
+- lib/ice_t/rule/minutely.rb
+- lib/ice_t/rule/monthly.rb
+- lib/ice_t/rule/repository.rb
+- lib/ice_t/rule/yearly.rb
+- lib/ice_t/schedule.rb
+- lib/ice_t/time_helper.rb
+- lib/ice_t/version.rb
+- lib/locales/en.yml
+- spec/exceptions_spec.rb
+- spec/rules/base_spec.rb
+- spec/rules/daily_rule_spec.rb
+- spec/rules/hourly_rule_spec.rb
+- spec/rules/minutely_rule_spec.rb
+- spec/rules/monthly_rule_spec.rb
+- spec/rules/rules_repository_spec.rb
+- spec/rules/yearly_rule_spec.rb
+- spec/schedule_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_examples/rule_example.rb
+homepage: https://github.com/XORwell/IceT
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Ruby Time Recurrence
+test_files:
+- spec/exceptions_spec.rb
+- spec/rules/base_spec.rb
+- spec/rules/daily_rule_spec.rb
+- spec/rules/hourly_rule_spec.rb
+- spec/rules/minutely_rule_spec.rb
+- spec/rules/monthly_rule_spec.rb
+- spec/rules/rules_repository_spec.rb
+- spec/rules/yearly_rule_spec.rb
+- spec/schedule_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_examples/rule_example.rb