acts_as_span 0.0.5

data/lib/acts_as_span/span_instance/validations.rb

@@ -0,0 +1,67 @@
+require 'active_support'
+
+module ActsAsSpan
+  class SpanInstance
+    module Validations
+      extend ActiveSupport::Concern
+      
+      module InstanceMethods
+        def validate
+          validate_start_date
+          validate_end_date
+          validate_start_date_less_than_or_equal_to_end_date
+          validate_overlap
+        end
+        
+        def validate_start_date
+          if start_date_field_required && start_date.blank?
+            span_model.errors.add(start_date_field, :blank)
+          end
+        end
+        
+        def validate_end_date
+          if end_date_field_required && end_date.blank?
+            span_model.errors.add(end_date_field, :blank)
+          end
+        end
+        
+        def validate_start_date_less_than_or_equal_to_end_date
+          if start_date && end_date && end_date < start_date
+            span_model.errors.add(end_date_field, "Must be on or after #{start_date_field}")
+          end
+        end
+
+        def validate_overlap
+          if span_overlap_count && span_model.errors[start_date_field].empty? && span_model.errors[end_date_field].empty? # && ( respond_to?('archived?') ? !archived? : true )
+            conditions = {}
+
+            if span_overlap_scope.is_a?(Array)
+              span_overlap_scope.each do |symbol|
+                conditions[symbol] = span_model.send(symbol)
+              end
+            elsif span_overlap_scope.is_a?(Symbol)
+              conditions[span_overlap_scope] = span_model.send(span_overlap_scope)
+            end
+
+            records = span_klass.span_for(name).overlap(self).where(conditions)
+
+            if span_klass.respond_to?('not_archived')
+              records.not_archived
+            end
+
+            #TODO - This will have to be an after_save callback...
+            #if span_overlap_auto_close
+            #  records.each do |record|
+            #    record.close!(start_date)
+            #  end
+            #end
+
+            if records.count > span_overlap_count
+              span_model.errors.add(:base, "date range overlaps with #{records.count} other record(s)")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_span/span_klass.rb

@@ -0,0 +1,31 @@
+require 'forwardable'
+
+require ACTS_AS_SPAN_PATH + 'span_klass/status'
+require ACTS_AS_SPAN_PATH + 'span_klass/overlap'
+
+module ActsAsSpan
+  class SpanKlass
+    extend Forwardable
+    
+    include ActsAsSpan::SpanKlass::Status
+    include ActsAsSpan::SpanKlass::Overlap
+    
+    def_delegators :@acts_as_span_definition, :start_date_field,
+                                              :end_date_field,
+                                              :start_date_field_required,
+                                              :end_date_field_required,
+                                              :exclude_end,
+                                              :span_overlap_scope,
+                                              :span_overlap_count
+    
+    def_delegators :klass, :table_name
+    
+    attr_reader :name, :klass, :acts_as_span_definition
+    
+    def initialize(name, klass, acts_as_span_definition)
+      @name = name
+      @klass = klass
+      @acts_as_span_definition = acts_as_span_definition
+    end
+  end
+end

data/lib/acts_as_span/span_klass/overlap.rb

@@ -0,0 +1,21 @@
+require 'active_support'
+
+module ActsAsSpan
+  class SpanKlass
+    module Overlap
+      extend ActiveSupport::Concern
+      
+      module InstanceMethods
+        def overlap(test_span)
+          overlap_scope = klass.where( ["(#{table_name}.#{start_date_field} IS NULL OR :end_date IS NULL OR #{table_name}.#{start_date_field} <= :end_date) AND (#{table_name}.#{end_date_field} IS NULL OR :start_date IS NULL OR :start_date <= #{table_name}.#{end_date_field})", { :start_date => test_span.start_date, :end_date => test_span.end_date } ] )
+
+          if !test_span.new_record? && test_span.span_klass == klass
+            overlap_scope.where( ["#{table_name}.id != :id", { :id => test_span.id } ] )
+          end
+
+          overlap_scope
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_span/span_klass/status.rb

@@ -0,0 +1,29 @@
+require 'active_support'
+
+module ActsAsSpan
+  class SpanKlass
+    module Status
+      extend ActiveSupport::Concern
+      
+      module InstanceMethods
+        def current(query_date = Date.today)
+          klass.where(["(#{table_name}.#{start_date_field} <= :query_date OR #{table_name}.#{start_date_field} IS NULL) AND (#{table_name}.#{end_date_field} >= :query_date OR #{table_name}.#{end_date_field} IS NULL)", { :query_date => query_date } ] )
+        end
+        
+        alias_method :current_on, :current
+
+        def future(query_date = Date.today)
+          klass.where(["#{table_name}.#{start_date_field} > :query_date", { :query_date => query_date } ] )
+        end
+        
+        alias_method :future_on, :future
+
+        def expired(query_date = Date.today)
+          klass.where(["#{table_name}.#{end_date_field} < :query_date", { :query_date => query_date } ] )
+        end
+        
+        alias_method :expired_on, :expired
+      end
+    end
+  end
+end

data/lib/acts_as_span/version.rb

@@ -0,0 +1,12 @@
+module ActsAsSpan
+  module VERSION
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 5
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+    
+    SUMMARY = "acts_as_span #{STRING}"
+  end
+end

data/spec/lib/acts_as_span_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe "acts_as_span" do
+  before(:each) do
+    build_model :span_model do
+      acts_as_span
+    end
+  end
+  
+  context "ClassMethods" do
+    it "should return true for acts_as_span?" do
+      SpanModel.acts_as_span?.should be_true
+    end
+    
+    it "should have 1 acts_as_span_definition" do
+      SpanModel.should have(1).acts_as_span_definitions
+    end
+    
+    it "should set default options for acts_as_span_definition" do
+      span_definition = SpanModel.acts_as_span_definitions[:default]
+      
+      span_definition.start_date_field.should == :start_date
+      span_definition.end_date_field.should == :end_date
+      span_definition.start_date_field_required.should be_false
+      span_definition.end_date_field_required.should be_false
+      span_definition.exclude_end.should be_false
+      span_definition.span_overlap_scope.should be_nil
+      span_definition.span_overlap_count.should be_nil
+      span_definition.name.should == :default
+    end
+    
+    it "should return a SpanKlass w/ span" do
+      SpanModel.span.should be_instance_of(ActsAsSpan::SpanKlass)
+    end
+
+    it "should return a SpanKlass w/ span_for(:default)" do
+      SpanModel.span_for(:default).should be_instance_of(ActsAsSpan::SpanKlass)
+    end
+    
+    it "should have (1) spans" do
+      SpanModel.spans.should have(1).span
+    end
+  end
+  
+  context "InstanceMethods" do
+    let(:span_model) { SpanModel.new }
+    
+    it "should return true for acts_as_span?" do
+      span_model.acts_as_span?.should be_true
+    end
+
+    it "should return a SpanInstance w/ span" do
+      span_model.span.should be_instance_of(ActsAsSpan::SpanInstance)
+    end
+
+    it "should return a SpanInstance w/ span_for(:default)" do
+      span_model.span_for(:default).should be_instance_of(ActsAsSpan::SpanInstance)
+    end
+    
+    it "should have (1) spans" do
+      span_model.spans.should have(1).span
+    end
+  end
+end

data/spec/lib/delegation_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe "Span" do
+  before(:each) do
+    build_model :span_model do
+      date  :start_date
+      date  :end_date
+      
+      acts_as_span
+    end
+  end
+  
+  let(:span_model) { SpanModel.new(:start_date => Date.today, :end_date => nil) }
+  let(:span_klass) { SpanModel.span }
+  let(:span_instance) { span_model.span }
+  
+  context "ClassMethods" do
+    it "should delegate current" do
+      span_klass.should_receive(:current).and_return(true)
+      
+      SpanModel.current
+    end
+    
+    it "should delegate current_on" do
+      span_klass.should_receive(:current_on).and_return(true)
+      
+      SpanModel.current_on
+    end
+    
+    it "should delegate future" do
+      span_klass.should_receive(:future).and_return(true)
+      
+      SpanModel.future
+    end
+    
+    it "should delegate future_on" do
+      span_klass.should_receive(:future_on).and_return(true)
+      
+      SpanModel.future_on
+    end
+    
+    it "should delegate expired" do
+      span_klass.should_receive(:expired).and_return(true)
+      
+      SpanModel.expired
+    end
+    
+    it "should delegate expired_on" do
+      span_klass.should_receive(:expired_on).and_return(true)
+      
+      SpanModel.expired_on
+    end
+  end
+  
+  context "InstanceMethods" do
+    it "should delegate close!" do
+      span_instance.should_receive(:close!).and_return(true)
+      
+      span_model.close!
+    end
+    
+    it "should delegate close_on!" do
+      span_instance.should_receive(:close_on!).and_return(true)
+      
+      span_model.close_on!
+    end
+    
+    it "should delegate span_status" do
+      span_instance.should_receive(:span_status).and_return(true)
+      
+      span_model.span_status
+    end
+    
+    it "should delegate span_status_on" do
+      span_instance.should_receive(:span_status_on).and_return(true)
+      
+      span_model.span_status_on
+    end
+    
+    it "should delegate span_status_to_s" do
+      span_instance.should_receive(:span_status_to_s).and_return(true)
+      
+      span_model.span_status_to_s
+    end
+    
+    it "should delegate span_status_to_s_on" do
+      span_instance.should_receive(:span_status_to_s_on).and_return(true)
+      
+      span_model.span_status_to_s_on
+    end
+    
+    it "should delegate current?" do
+      span_instance.should_receive(:current?).and_return(true)
+      
+      span_model.current?
+    end
+    
+    it "should delegate current_on?" do
+      span_instance.should_receive(:current_on?).and_return(true)
+      
+      span_model.current_on?
+    end
+    
+    it "should delegate future?" do
+      span_instance.should_receive(:future?).and_return(true)
+      
+      span_model.future?
+    end
+    
+    it "should delegate future_on?" do
+      span_instance.should_receive(:future_on?).and_return(true)
+      
+      span_model.future_on?
+    end
+    
+    it "should delegate expired?" do
+      span_instance.should_receive(:expired?).and_return(true)
+      
+      span_model.expired?
+    end
+    
+    it "should delegate expired_on?" do
+      span_instance.should_receive(:expired_on?).and_return(true)
+      
+      span_model.expired_on?
+    end
+  end
+end

data/spec/lib/negative_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe "acts_as_span" do
+  before(:each) do
+    build_model :negative_model do
+    end
+  end
+    
+  context "NegativeModel (Class)" do
+    it "should respond_to acts_as_span" do
+      NegativeModel.should respond_to(:acts_as_span)
+    end
+    
+    it "should return false for acts_as_span?" do
+      NegativeModel.acts_as_span?.should be_false
+    end
+    
+    it "should have no acts_as_span_definitions" do
+      NegativeModel.acts_as_span_definitions.should be_empty
+    end
+  end
+  
+  context "NegativeModel (Instance)" do
+    let(:negative_model) { NegativeModel.new }
+    
+    it "should return false for acts_as_span?" do
+      negative_model.acts_as_span?.should be_false
+    end
+  end
+end

data/spec/lib/span_instance/named_scopes_on_spec.rb

@@ -0,0 +1,304 @@
+require 'spec_helper'
+
+describe "a basic model using acts_as_span" do
+  before(:all) do 
+    build_model :span_model do
+      string   :description
+      date     :start_date
+      date     :end_date
+      
+      acts_as_span
+    end
+    
+    @query_date = Date.today + 1.month
+  end
+  
+  context "named_scopes and current_on?, expired_on?, and future_on?" do
+    #    -2  -1   Q  +1  +2      C F E
+    # A   |---|                      E
+    # B   |-------|              C    
+    # C   |--------------|       C    
+    # D           |              C    
+    # E           |------|       C    
+    # F               |--|         F  
+    # G   |->                    C    
+    # H           |->            C    
+    # I               |->          F  
+    # J     <-|                      E
+    # K         <-|              C    
+    # L                <-|       C    
+    # M           <->            C    
+    context "A) start_date < query_date & end_date < query_date" do
+      before(:all) do
+        @span_model = SpanModel.create!(:start_date => @query_date - 2.days, :end_date => @query_date - 1.day)
+      end
+      
+      it "should NOT be included in #current" do
+        SpanModel.current_on(@query_date).should_not include(@span_model)
+        @span_model.current_on?(@query_date).should be_false
+      end
+      
+      it "should NOT be included in #future" do
+        SpanModel.future_on(@query_date).should_not include(@span_model)
+        @span_model.future_on?(@query_date).should be_false
+      end
+      
+      it "should be included in #expired" do
+        SpanModel.expired_on(@query_date).should include(@span_model)
+        @span_model.expired_on?(@query_date).should be_true
+      end
+    end
+    
+    context "B) start_date < query_date & end_date == query_date" do
+      before(:all) do
+        @span_model = SpanModel.create!(:start_date => @query_date - 2.day, :end_date => @query_date)
+      end
+      
+      it "should be included in #current" do
+        SpanModel.current_on(@query_date).should include(@span_model)
+        @span_model.current_on?(@query_date).should be_true
+      end
+      
+      it "should NOT be included in #future" do
+        SpanModel.future_on(@query_date).should_not include(@span_model)
+        @span_model.future_on?(@query_date).should be_false
+      end
+      
+      it "should NOT be included in #expired" do
+        SpanModel.expired_on(@query_date).should_not include(@span_model)
+        @span_model.expired_on?(@query_date).should be_false
+      end
+    end
+    
+    context "C) start_date < query_date & end_date > query_date" do
+      before(:all) do
+        @span_model = SpanModel.create!(:start_date => @query_date - 2.day, :end_date => @query_date + 2.day)
+      end
+      
+      it "should be included in #current" do
+        SpanModel.current_on(@query_date).should include(@span_model)
+        @span_model.current_on?(@query_date).should be_true
+      end
+      
+      it "should NOT be included in #future" do
+        SpanModel.future_on(@query_date).should_not include(@span_model)
+        @span_model.future_on?(@query_date).should be_false
+      end
+      
+      it "should NOT be included in #expired" do
+        SpanModel.expired_on(@query_date).should_not include(@span_model)
+        @span_model.expired_on?(@query_date).should be_false
+      end
+    end
+    
+    context "D) start_date == query_date & end_date == query_date" do
+      before(:all) do
+        @span_model = SpanModel.create!(:start_date => @query_date, :end_date => @query_date)
+      end
+      
+      it "should be included in #current" do
+        SpanModel.current_on(@query_date).should include(@span_model)
+        @span_model.current_on?(@query_date).should be_true
+      end
+      
+      it "should NOT be included in #future" do
+        SpanModel.future_on(@query_date).should_not include(@span_model)
+        @span_model.future_on?(@query_date).should be_false
+      end
+      
+      it "should NOT be included in #expired" do
+        SpanModel.expired_on(@query_date).should_not include(@span_model)
+        @span_model.expired_on?(@query_date).should be_false
+      end
+    end
+    
+    context "E) start_date == query_date & end_date > query_date" do
+      before(:all) do
+        @span_model = SpanModel.create!(:start_date => @query_date, :end_date => @query_date + 2.day)
+      end
+      
+      it "should be included in #current" do
+        SpanModel.current_on(@query_date).should include(@span_model)
+        @span_model.current_on?(@query_date).should be_true
+      end
+      
+      it "should NOT be included in #future" do
+        SpanModel.future_on(@query_date).should_not include(@span_model)
+        @span_model.future_on?(@query_date).should be_false
+      end
+      
+      it "should NOT be included in #expired" do
+        SpanModel.expired_on(@query_date).should_not include(@span_model)
+        @span_model.expired_on?(@query_date).should be_false
+      end
+    end
+    
+    context "F) start_date > query_date & end_date > query_date" do
+      before(:all) do
+        @span_model = SpanModel.create!(:start_date => @query_date + 1.day, :end_date => @query_date + 2.days)
+      end
+      
+      it "should NOT be included in #current" do
+        SpanModel.current_on(@query_date).should_not include(@span_model)
+        @span_model.current_on?(@query_date).should be_false
+      end
+      
+      it "should be included in #future" do
+        SpanModel.future_on(@query_date).should include(@span_model)
+        @span_model.future_on?(@query_date).should be_true
+      end
+      
+      it "should NOT be included in #expired" do
+        SpanModel.expired_on(@query_date).should_not include(@span_model)
+        @span_model.expired_on?(@query_date).should be_false
+      end
+    end
+    
+    context "G) start_date < query_date & end_date == nil" do
+      before(:all) do
+        @span_model = SpanModel.create!(:start_date => @query_date - 2.day, :end_date => nil)
+      end
+      
+      it "should be included in #current" do
+        SpanModel.current_on(@query_date).should include(@span_model)
+        @span_model.current_on?(@query_date).should be_true
+      end
+      
+      it "should NOT be included in #future" do
+        SpanModel.future_on(@query_date).should_not include(@span_model)
+        @span_model.future_on?(@query_date).should be_false
+      end
+      
+      it "should NOT be included in #expired" do
+        SpanModel.expired_on(@query_date).should_not include(@span_model)
+        @span_model.expired_on?(@query_date).should be_false
+      end
+    end
+    
+    context "H) start_date == query_date & end_date == nil" do
+      before(:all) do
+        @span_model = SpanModel.create!(:start_date => @query_date, :end_date => nil)   
+      end
+      
+      it "should be included in #current" do
+        SpanModel.current_on(@query_date).should include(@span_model)
+        @span_model.current_on?(@query_date).should be_true
+      end
+      
+      it "should NOT be included in #future" do
+        SpanModel.future_on(@query_date).should_not include(@span_model)
+        @span_model.future_on?(@query_date).should be_false
+      end
+      
+      it "should NOT be included in #expired" do
+        SpanModel.expired_on(@query_date).should_not include(@span_model)
+        @span_model.expired_on?(@query_date).should be_false
+      end
+    end
+    
+    context "I) start_date > query_date & end_date == nil" do
+      before(:all) do
+        @span_model = SpanModel.create!(:start_date => @query_date + 1.day, :end_date => nil)
+      end
+      
+      it "should NOT be included in #current" do
+        SpanModel.current_on(@query_date).should_not include(@span_model)
+        @span_model.current_on?(@query_date).should be_false
+      end
+      
+      it "should be included in #future" do
+        SpanModel.future_on(@query_date).should include(@span_model)
+        @span_model.future_on?(@query_date).should be_true
+      end
+      
+      it "should NOT be included in #expired" do
+        SpanModel.expired_on(@query_date).should_not include(@span_model)
+        @span_model.expired_on?(@query_date).should be_false
+      end
+    end
+    
+    context "J) start_date == nil & end_date < query_date" do
+      before(:all) do
+        @span_model = SpanModel.create!(:start_date => nil, :end_date => @query_date - 1.day)
+      end
+      
+      it "should NOT be included in #current" do
+        SpanModel.current_on(@query_date).should_not include(@span_model)
+        @span_model.current_on?(@query_date).should be_false
+      end
+      
+      it "should NOT be included in #future" do
+        SpanModel.future_on(@query_date).should_not include(@span_model)
+        @span_model.future_on?(@query_date).should be_false
+      end
+      
+      it "should be included in #expired" do
+        SpanModel.expired_on(@query_date).should include(@span_model)
+        @span_model.expired_on?(@query_date).should be_true
+      end
+    end
+    
+    context "K) start_date == nil & end_date == query_date" do
+      before(:all) do
+        @span_model = SpanModel.create!(:start_date => nil, :end_date => @query_date)
+      end
+      
+      it "should be included in #current" do
+        SpanModel.current_on(@query_date).should include(@span_model)
+        @span_model.current_on?(@query_date).should be_true
+      end
+      
+      it "should NOT be included in #future" do
+        SpanModel.future_on(@query_date).should_not include(@span_model)
+        @span_model.future_on?(@query_date).should be_false
+      end
+      
+      it "should NOT be included in #expired" do
+        SpanModel.expired_on(@query_date).should_not include(@span_model)
+        @span_model.expired_on?(@query_date).should be_false
+      end
+    end
+    
+    context "L) start_date == nil & end_date > query_date" do
+      before(:all) do
+        @span_model = SpanModel.create!(:start_date => nil, :end_date => @query_date + 2.day)
+      end
+      
+      it "should be included in #current" do
+        SpanModel.current_on(@query_date).should include(@span_model)
+        @span_model.current_on?(@query_date).should be_true
+      end
+      
+      it "should NOT be included in #future" do
+        SpanModel.future_on(@query_date).should_not include(@span_model)
+        @span_model.future_on?(@query_date).should be_false
+      end
+      
+      it "should NOT be included in #expired" do
+        SpanModel.expired_on(@query_date).should_not include(@span_model)
+        @span_model.expired_on?(@query_date).should be_false
+      end
+    end
+    
+    context "M) start_date == nil & end_date == nil" do
+      before(:all) do
+        @span_model = SpanModel.create!(:start_date => nil, :end_date => nil)
+      end
+      
+      it "should be included in #current" do
+        SpanModel.current_on(@query_date).should include(@span_model)
+        @span_model.current_on?(@query_date).should be_true
+      end
+      
+      it "should NOT be included in #future" do
+        SpanModel.future_on(@query_date).should_not include(@span_model)
+        @span_model.future_on?(@query_date).should be_false
+      end
+      
+      it "should NOT be included in #expired" do
+        SpanModel.expired_on(@query_date).should_not include(@span_model)
+        @span_model.expired_on?(@query_date).should be_false
+      end
+    end
+  end
+end