acts_as_span 0.0.5 → 0.0.6

data/lib/acts_as_span/span_instance/status.rb

@@ -1,12 +1,10 @@
-require 'active_support'
-
 module ActsAsSpan
   class SpanInstance
     module Status
       extend ActiveSupport::Concern
-      
-      module InstanceMethods
-        def span_status(query_date = Date.today)
+
+      included do
+        def span_status(query_date = Date.current)
           if future?(query_date)
             :future
           elsif expired?(query_date)
@@ -20,39 +18,26 @@ module ActsAsSpan
 
         alias_method :span_status_on, :span_status
 
-        def span_status_to_s(query_date = Date.today)
-          case span_status(query_date)
-          when :future
-            "Future"
-          when :expired
-            "Expired"
-          when :current
-            "Current"
-          when :unknown
-            "Unknown"
-          end
-        end
-
-        alias_method :span_status_to_s_on, :span_status_to_s
-        
-        def current?(query_date = Date.today)
+        def current?(query_date = Date.current)
           !future?(query_date) && !expired?(query_date)
         end
-        
+
         alias_method :current_on?, :current?
 
-        def future?(query_date = Date.today)
+        def future?(query_date = Date.current)
           start_date && start_date > query_date
         end
-        
+
         alias_method :future_on?, :future?
 
-        def expired?(query_date = Date.today)
+        def expired?(query_date = Date.current)
           end_date && end_date < query_date
         end
-        
+
         alias_method :expired_on?, :expired?
+        alias_method :past_on?, :expired?
+        alias_method :past?, :expired?
       end
     end
   end
-end
+end

data/lib/acts_as_span/span_instance/validations.rb

@@ -1,67 +1,19 @@
-require 'active_support'
-
 module ActsAsSpan
   class SpanInstance
     module Validations
       extend ActiveSupport::Concern
-      
-      module InstanceMethods
+
+      included do
         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
+            span_model.errors.add(end_field, "Must be on or after #{start_field}")
           end
         end
       end
     end
   end
-end
+end

data/lib/acts_as_span/span_klass.rb

@@ -1,31 +1,23 @@
-require 'forwardable'
+require 'acts_as_span/span_klass/status'
 
-require ACTS_AS_SPAN_PATH + 'span_klass/status'
-require ACTS_AS_SPAN_PATH + 'span_klass/overlap'
+require 'active_support/core_ext/module/delegation'
 
 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
-    
+
+    delegate :start_field,
+             :end_field,
+             :exclude_end, to: :@acts_as_span_definition
+
+    delegate :table_name, :arel_table, to: :klass, allow_nil: true
+
     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
+end

data/lib/acts_as_span/span_klass/status.rb

@@ -4,26 +4,47 @@ 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 } ] )
+
+      included do
+        def current(query_date = Date.current)
+          klass.where(
+            (arel_table[start_field].lteq(query_date).or(arel_table[start_field].eq(nil))).
+            and(
+              arel_table[end_field].eq(nil).or(arel_table[end_field].gteq(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 } ] )
+        def future(query_date = Date.current)
+          klass.where(arel_table[start_field].gt(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 } ] )
+        def expired(query_date = Date.current)
+          klass.where(arel_table[end_field].lt(query_date))
         end
-        
+
         alias_method :expired_on, :expired
+        alias_method :past_on, :expired
+        alias_method :past, :expired
+
+
+        def current_or_future_on(query_date = Date.current)
+          klass.where(
+            arel_table[start_field].lteq(query_date).
+            and(
+              arel_table[end_field].eq(nil).
+              or(arel_table[end_field].gteq(query_date))
+            ).
+            or(arel_table[start_field].gt(query_date))
+          )
+        end
+
+        alias_method :current_or_future, :current_or_future_on
       end
     end
   end
-end
+end

data/lib/acts_as_span/version.rb

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

data/lib/acts_as_span/within_parent_date_span_validator.rb

@@ -0,0 +1,42 @@
+module ActsAsSpan
+  class WithinParentDateSpanValidator < ActiveModel::Validator
+    def validate(record)
+      parents = options[:parent] || options[:parents]
+
+      Array(parents).each do |parent|
+        record.errors.add(:base, :not_within_parent_date_span, parent: record.class.human_attribute_name(parent)) if outside_of_parent_date_span?(record, parent)
+      end
+    end
+
+    def outside_of_parent_date_span?(record, parent_sym)
+      parent = record.send(parent_sym)
+
+      return false if parent.nil?
+
+        child_record_without_start_date(record, parent) ||
+        child_record_without_end_date(record, parent) ||
+        child_record_started_before_parent_record(record, parent) ||
+          child_record_ended_after_parent_record(record, parent)
+    end
+
+    private
+
+    def child_record_started_before_parent_record(record, parent)
+      record.start_date.present? && parent.start_date.present? &&
+        record.start_date < parent.start_date
+    end
+
+    def child_record_ended_after_parent_record(record, parent)
+      record.end_date.present? && parent.end_date.present? &&
+        record.end_date > parent.end_date
+    end
+
+    def child_record_without_start_date(record, parent)
+      record.start_date.nil? && parent.start_date.present?
+    end
+
+    def child_record_without_end_date(record, parent)
+      record.end_date.nil? && parent.end_date.present?
+    end
+  end
+end

data/spec/lib/acts_as_span_spec.rb

@@ -1,64 +1,46 @@
 require 'spec_helper'
 
-describe "acts_as_span" do
-  before(:each) do
-    build_model :span_model do
-      acts_as_span
-    end
-  end
-  
+RSpec.describe "acts_as_span" do
   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
+      expect(SpanModel.acts_as_span_definitions.size).to eq(1)
     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
+
+      expect(span_definition.start_field).to eq(:start_date)
+      expect(span_definition.end_field).to eq(:end_date)
+      expect(span_definition.exclude_end).to be_falsey
+      expect(span_definition.name).to eq(:default)
     end
-    
+
     it "should return a SpanKlass w/ span" do
-      SpanModel.span.should be_instance_of(ActsAsSpan::SpanKlass)
+      expect(SpanModel.span).to 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)
+      expect(SpanModel.span_for(:default)).to be_instance_of(ActsAsSpan::SpanKlass)
     end
-    
+
     it "should have (1) spans" do
-      SpanModel.spans.should have(1).span
+      expect(SpanModel.spans.size).to eq(1)
     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)
+      expect(span_model.span).to 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)
+      expect(span_model.span_for(:default)).to be_instance_of(ActsAsSpan::SpanInstance)
     end
-    
+
     it "should have (1) spans" do
-      span_model.spans.should have(1).span
+      expect(span_model.spans.size).to eq(1)
     end
   end
 end

data/spec/lib/delegation_spec.rb

@@ -1,128 +1,95 @@
 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) }
+RSpec.describe "Span" do
+  let(:span_model) { SpanModel.new(:start_date => Date.current, :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)
-      
+      expect(span_klass).to receive(:current).and_return(true)
+
       SpanModel.current
     end
-    
+
     it "should delegate current_on" do
-      span_klass.should_receive(:current_on).and_return(true)
-      
+      expect(span_klass).to receive(:current_on).and_return(true)
+
       SpanModel.current_on
     end
-    
+
     it "should delegate future" do
-      span_klass.should_receive(:future).and_return(true)
-      
+      expect(span_klass).to receive(:future).and_return(true)
+
       SpanModel.future
     end
-    
+
     it "should delegate future_on" do
-      span_klass.should_receive(:future_on).and_return(true)
-      
+      expect(span_klass).to receive(:future_on).and_return(true)
+
       SpanModel.future_on
     end
-    
+
     it "should delegate expired" do
-      span_klass.should_receive(:expired).and_return(true)
-      
+      expect(span_klass).to receive(:expired).and_return(true)
+
       SpanModel.expired
     end
-    
+
     it "should delegate expired_on" do
-      span_klass.should_receive(:expired_on).and_return(true)
-      
+      expect(span_klass).to 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)
-      
+      expect(span_instance).to 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)
-      
+      expect(span_instance).to 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)
-      
+      expect(span_instance).to receive(:current?).and_return(true)
+
       span_model.current?
     end
-    
+
     it "should delegate current_on?" do
-      span_instance.should_receive(:current_on?).and_return(true)
-      
+      expect(span_instance).to receive(:current_on?).and_return(true)
+
       span_model.current_on?
     end
-    
+
     it "should delegate future?" do
-      span_instance.should_receive(:future?).and_return(true)
-      
+      expect(span_instance).to receive(:future?).and_return(true)
+
       span_model.future?
     end
-    
+
     it "should delegate future_on?" do
-      span_instance.should_receive(:future_on?).and_return(true)
-      
+      expect(span_instance).to receive(:future_on?).and_return(true)
+
       span_model.future_on?
     end
-    
+
     it "should delegate expired?" do
-      span_instance.should_receive(:expired?).and_return(true)
-      
+      expect(span_instance).to receive(:expired?).and_return(true)
+
       span_model.expired?
     end
-    
+
     it "should delegate expired_on?" do
-      span_instance.should_receive(:expired_on?).and_return(true)
-      
+      expect(span_instance).to receive(:expired_on?).and_return(true)
+
       span_model.expired_on?
     end
   end
-end
+end