acts_as_span 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1b2bd958d53e10e1816b39bbb073c8b9d21b105ab20b7bdd1d0f11048f2adf7
-  data.tar.gz: 9f211ee95efdcbad216591259729983fbf31fc26f6ce91d39fdd03be258d0c0e
+  metadata.gz: 57404b0d110113b5f9c52537aa90970a560d69f4a5b7d5d318caacc229157679
+  data.tar.gz: 5702fafe912d1bc56b633aec32dd2ae76da9f886608c182eed29c0ca7d2ed509
 SHA512:
-  metadata.gz: aa5735e3051308f569cee93a81b13b833c33c1611feaacc0cfc2b985f1938dbaac923676bcd5e0fc75ed91f428651a3b2e10ff2a4ed48981e6191acc60494bd1
-  data.tar.gz: 2fc6f890b396e9829559aa063f6bdd6dfb21b1afc0806a83dc1114acbc736af6ce0cf6dec2c319a259ad1adfdbd52657f81c2adc439b32a3d05c4844f179b7f5
+  metadata.gz: b1e7265d3cfc7433b331f407fe991eb5549091e10c5dcef0298468099f1769dfaca71a7355363af8f6f88c381362d518fa494366d3f1dead8de8072458d95b2c
+  data.tar.gz: 6304cb8600c553e60bc7e470ed4f87e6cc145a4239243f5109556278f76d88b24d1624bbc904e499d7ce95d7196967d4d8822c962571c9184c875dbd20d6d57f

data/.tool-versions

@@ -0,0 +1 @@
+ruby 2.6.3

data/acts_as_span.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "bundler", "~> 2.0.1"
   s.add_development_dependency "rake", "~> 10.0"
   s.add_development_dependency "rspec", "~> 3.0"
-  s.add_development_dependency "sqlite3", "~> 1.3.6"
+  s.add_development_dependency "sqlite3", "~> 1.4"
   s.add_development_dependency "has_siblings", "~> 0.2.7"
   s.add_development_dependency "temping"
   s.add_development_dependency "pry-byebug"

data/config/locales/en/acts_as_span.yml

@@ -0,0 +1,15 @@
+en:
+  activerecord:
+    errors:
+      messages:
+        end_date_propagator:
+          propagation_failure: "%{parent} could not propagate
+           %{end_date_field_name} to %{child}:\n%{reason}"
+        # TODO: let pluralize handle pluralization
+        no_overlap:
+          one: "A %{model_name} already exists between
+           %{start_date} - %{end_date}: %{overlapping_records_s}"
+          other: "%{count} %{model_name_plural} already exist between
+           %{start_date} - %{end_date}: %{overlapping_records_s}"
+        not_within_parent_date_span: Must exist within the %{parent} date span
+        start_date_after_end_date: Must be on or after %{start_field}

data/lib/acts_as_span.rb

@@ -6,10 +6,13 @@ require 'acts_as_span/span_instance'
 require 'acts_as_span/no_overlap_validator'
 require 'acts_as_span/within_parent_date_span_validator'
 
+require 'acts_as_span/end_date_propagator'
 
 require 'active_support'
 require 'active_record'
 
+I18n.load_path += Dir[File.join(File.dirname(__dir__), 'config', 'locales', '**', 'acts_as_span.yml')]
+
 module ActsAsSpan
   extend ActiveSupport::Concern
 

data/lib/acts_as_span/end_date_propagator.rb

@@ -0,0 +1,190 @@
+# frozen_string_Literal: true
+
+module ActsAsSpan
+  # # End Date Propagator
+  #
+  # When editing the `end_date` of a record, the record's children often also
+  #   need to be updated. This propagator takes care of that.
+  # For each of the  child records (defined below in the function `children`),
+  #   the child record's `end_date` is updated to match that of the original
+  #   object. The function `propagate` is recursive, propagating to
+  #   children of children and so on.
+  # Records that should not have their end dates propagated in this manner
+  #   (e.g. StatusRecords) are manually excluded in `skipped_classes`.
+  # If there is some error preventing propagation, the child record is NOT saved
+  #   and that error message is added to the object's `errors`. These errors
+  #   propagate upwards into a flattened array of error messages.
+  #
+  # This class uses its own definition of 'child' for an object. For a given
+  #   object, the objects the propagator considers its children are:
+  #   * Associated via `has_many` association
+  #   * Association `:dependent` option is `:delete` or `:destroy`
+  #   * acts_as_span (checked via `respond_to?(:span)`)
+  #   * Not blacklisted via `skipped_classes` array
+  #
+  # The return value for `call` is the given object, updated to have children's
+  #   errors added to its `:base` errors if any children had errors.
+  #
+  # ## Usage:
+  #
+  # Propagate end dates for an object that acts_as_span and has propagatable
+  # children to all propagatable children:
+  # ```
+  # ActsAsSpan::EndDatePropagator.call(object)
+  # ```
+  #
+  # To propagate to a subset of its propagatable children:
+  # ```
+  # ActsAsSpan::EndDatePropagator.call(
+  #   object, skipped_classes: [ClassOne, ClassTwo]
+  # )
+  # ```
+  # ... where ClassOne and ClassTwo are the classes to be excluded.
+  #
+  # The EndDatePropagator does not use transactions. If the propagation should
+  # be run in a transaction, wrap the call in one like so:
+  # ```
+  # ActiveRecord::Base.transaction do
+  #   ActsAsSpan::EndDatePropagator.call(
+  #     obj, skipped_classes: [ClassOne, ClassTwo]
+  #   )
+  # end
+  # ```
+  #
+  # One use case for the transaction wrapper would be to not follow through
+  # with propagation if the object has errors:
+  # ```
+  # ActiveRecord::Base.transaction do
+  #   result = ActsAsSpan::EndDatePropagator.call(obj)
+  #   if result.errors.present?
+  #     fail OhNoMyObjetHasErrorsError, "Oh, no! My object has errors!"
+  #   end
+  # end
+  # ```
+  #
+  # Currently only propagates "default" span. The approach to implementing such
+  #   a feature is ambiguous - would all children have the same span propagated?
+  #   Would each acts_as_span model need a method to tell which span to
+  #   propagate to? Once there is a solid use case for using this object on
+  #   models with multiple spans, that will inform the implementation strategy.
+  class EndDatePropagator
+    attr_reader :object,
+                :errors_cache,
+                :skipped_classes
+
+    def initialize(object, errors_cache: [], skipped_classes: [])
+      @object = object
+      @errors_cache = errors_cache
+      @skipped_classes = skipped_classes
+    end
+
+    # class-level call: enable the usage of ActsAsSpan::EndDatePropagator.call
+    def self.call(object, **opts)
+      new(object, opts).call
+    end
+
+    def call
+      result = propagate
+      # only add new errors to the object
+      result.errors.each do |error, message|
+        unless object.errors[error].include? message
+          object.errors[error] << message
+        end
+      end
+      object
+    end
+
+    private
+
+    def propagate
+      # return if there is nothing to propagate
+      return object unless should_propagate_from? object
+
+      children(object).each do |child|
+        # End the record, its children too. And their children, forever, true.
+        propagated_child = assign_end_date(child, object.span.end_date)
+
+        # save child and add errors to cache
+        save_with_errors(object, child, propagated_child)
+      end
+
+      # add just the strings, prevent ugly nested arrays in the view
+      object.errors[:base].push(*errors_cache.flatten)
+
+      # return the object, with any newly-added errors
+      object
+    end
+
+    # returns the given child, but possibly with errors
+    def assign_end_date(child, new_end_date)
+      child.assign_attributes({ child.span.end_field => new_end_date })
+      ActsAsSpan::EndDatePropagator.call(
+        child, errors_cache: errors_cache, skipped_classes: skipped_classes
+      )
+    end
+
+    # save the child record, add errors.
+    def save_with_errors(object, child, propagated_child)
+      if object_has_errors?(propagated_child)
+        errors_cache << propagation_error_message(object, child)
+      end
+      child.save
+    end
+
+    def propagation_error_message(object, child)
+      I18n.t(
+        'propagation_failure',
+        scope: %i[activerecord errors messages end_date_propagator],
+        end_date_field_name: child.class.human_attribute_name(
+          child.span.end_field
+        ),
+        parent: object.model_name.human,
+        child: child.model_name.human,
+        reason: child.errors.full_messages.join('; ')
+      )
+    end
+
+    def object_has_errors?(object)
+      !object.valid? ||
+        (object.errors.present? && object.errors.messages.values.flatten.any?)
+    end
+
+    # check if the end_date analog is dirtied
+    def end_date_changed?(object)
+      end_date_field = object.span.end_field.to_s
+      object.changed.include? end_date_field
+    end
+
+    def should_propagate_from?(object)
+      object.respond_to?(:span) &&
+        end_date_changed?(object) &&
+        !object.span.end_date.nil?
+    end
+
+    # Use acts_as_span to determine whether a record has an end date
+    def should_propagate_to?(klass)
+      klass.respond_to?(:span) &&
+        @skipped_classes.exclude?(klass)
+    end
+
+    def child_associations(object)
+      object.class.reflect_on_all_associations(:has_many).select do |reflection|
+        %i[delete destroy].include?(reflection.options[:dependent]) &&
+          should_propagate_to?(reflection.klass)
+      end
+    end
+
+    def children(object)
+      child_objects = child_associations(object).flat_map do |reflection|
+        object.send(reflection.name)
+      end
+
+      # skip previously-ended children
+      child_objects.reject do |child|
+        child.span.end_date && child.span.end_date < object.span.end_date
+      end
+    end
+
+    attr_writer :object, :errors_cache
+  end
+end

data/lib/acts_as_span/no_overlap_validator.rb

@@ -4,19 +4,21 @@ module ActsAsSpan
   class NoOverlapValidator < ActiveModel::Validator
     def validate(record)
       overlapping_records = temporally_overlapping_for(record)
-      instance_scope = options[:instance_scope].is_a?(Proc) ? record.instance_eval(&options[:instance_scope]) : true
+      instance_scope = if options[:instance_scope].is_a? Proc
+                         record.instance_eval&options[:instance_scope]
+                       else
+                         true
+                       end
 
       if overlapping_records.any? && instance_scope
 
-        error_type = overlapping_records.size == 1 ? "no_overlap.one" : "no_overlap.other"
-
         record.errors.add(
           :base,
-          error_type.to_sym,
+          :no_overlap,
           model_name: record.class.model_name.human,
           model_name_plural: record.class.model_name.plural.humanize,
-          start_date: record.start_date,
-          end_date: record.end_date,
+          start_date: record.span.start_date,
+          end_date: record.span.end_date,
           count: overlapping_records.size,
           overlapping_records_s: overlapping_records.join(",")
         )
@@ -24,26 +26,26 @@ module ActsAsSpan
     end
 
     #TODO add back condition for start_date nil
-    #TODO add configuration for span configuration
+    #TODO add support for multiple spans (currently only checks :default)
     def temporally_overlapping_for(record)
       scope = record.instance_eval(&options[:scope])
 
-      start_date = record.start_date || Date.current
-      end_date = record.end_date
+      start_date = record.span.start_date || Date.current
+      end_date = record.span.end_date
       arel_table = record.class.arel_table
 
       if end_date
         scope.where(
-          arel_table[:start_date].lteq(end_date).
-          and(
-            arel_table[:end_date].gteq(start_date).
-            or(arel_table[:end_date].eq(nil))
+          arel_table[record.span.start_field].lteq(end_date)
+          .and(
+            arel_table[record.span.end_field].gteq(start_date)
+          .or(arel_table[record.span.end_field].eq(nil))
           )
         )
       else
         scope.where(
-          arel_table[:end_date].gteq(start_date).
-          or(arel_table[:end_date].eq(nil))
+          arel_table[record.span.end_field].gteq(start_date)
+          .or(arel_table[record.span.end_field].eq(nil))
         )
       end
     end

data/lib/acts_as_span/span_instance/validations.rb

@@ -10,7 +10,13 @@ module ActsAsSpan
 
         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_field, "Must be on or after #{start_field}")
+            span_model.errors.add(
+              end_field,
+              :start_date_after_end_date,
+              start_field: span_model.class.human_attribute_name(
+                span_model.span.start_field
+              )
+            )
           end
         end
       end

data/lib/acts_as_span/version.rb

@@ -1,7 +1,7 @@
 module ActsAsSpan
   module VERSION
     MAJOR = 1
-    MINOR = 0
+    MINOR = 1
     TINY  = 0
     PRE   = nil
 

data/lib/acts_as_span/within_parent_date_span_validator.rb

@@ -22,21 +22,21 @@ module ActsAsSpan
     private
 
     def child_record_started_before_parent_record(record, parent)
-      record.start_date.present? && parent.start_date.present? &&
-        record.start_date < parent.start_date
+      record.span.start_date.present? && parent.span.start_date.present? &&
+        record.span.start_date < parent.span.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
+      record.span.end_date.present? && parent.span.end_date.present? &&
+        record.span.end_date > parent.span.end_date
     end
 
     def child_record_without_start_date(record, parent)
-      record.start_date.nil? && parent.start_date.present?
+      record.span.start_date.nil? && parent.span.start_date.present?
     end
 
     def child_record_without_end_date(record, parent)
-      record.end_date.nil? && parent.end_date.present?
+      record.span.end_date.nil? && parent.span.end_date.present?
     end
   end
 end

data/spec/lib/end_date_propagator_spec.rb

@@ -0,0 +1,306 @@
+require 'spec_helper'
+
+RSpec.describe ActsAsSpan::EndDatePropagator do
+  let(:end_date_propagator) do
+    ActsAsSpan::EndDatePropagator.new(
+      base_instance, skipped_classes: skipped_classes
+    )
+  end
+
+  let(:base_instance) do
+    Base.create(end_date: initial_end_date)
+  end
+  let(:initial_end_date) { nil }
+
+  let(:other_base_instance) do
+    OtherBase.create(end_date: other_end_date)
+  end
+  let(:other_end_date) { nil }
+
+  let(:skipped_classes) { [] }
+
+  let!(:child_instance) do
+    Child.create(
+      base: base_instance,
+      emancipation_date: child_end_date
+    )
+  end
+  let(:child_end_date) { nil }
+
+  let!(:dog_instance) do
+    Dog.create(
+      base: base_instance,
+      end_date: dog_end_date
+    )
+  end
+  let(:dog_end_date) { nil }
+
+  let!(:bird_instance) do
+    Bird.create(
+      child: child_instance,
+      end_date: child_end_date
+    )
+  end
+  let(:bird_end_date) { nil }
+
+  let(:tale_instance) do
+    base_instance.tales.create(start_date: Date.current, end_date: nil)
+  end
+
+  describe '@errors_cache' do
+    let(:base_start_date) { Date.current - 7 }
+    let(:initial_end_date) { nil }
+    let(:end_date) { Date.current }
+
+    let(:child_start_date) { base_start_date + 1 }
+    let!(:child_instance) do
+      Child.create(
+        base: base_instance,
+        date_of_birth: child_start_date,
+        emancipation_date: child_end_date
+      )
+    end
+    let(:bird_start_date) { child_start_date + 1 }
+    let!(:bird_instance) do
+      Bird.create(
+        child: child_instance,
+        start_date: bird_start_date,
+        end_date: bird_end_date
+      )
+    end
+
+    before do
+      base_instance.start_date = base_start_date
+      base_instance.save!
+      base_instance.end_date = end_date
+    end
+
+    context 'when all child records are successfully saved' do
+      it 'the parent record does not have any errors' do
+        expect(
+          end_date_propagator.call.errors.full_messages
+        ).to be_empty
+      end
+    end
+
+    context 'when one grandchild record is not valid' do
+      before do
+        bird_instance.start_date = child_start_date - 1
+        bird_instance.save(validate: false)
+      end
+      it "the parent shows that grandchild's errors" do
+        expect(
+          end_date_propagator.call.errors.values.join
+        ).to include(
+          I18n.t(
+            'not_within_parent_date_span',
+            parent: 'Child',
+            scope: %i[activerecord errors messages]
+          )
+        )
+      end
+    end
+
+    context 'when multiple child records are not valid' do
+      before do
+        child_instance.date_of_birth = base_instance.span.start_date - 1
+        child_instance.save(validate: false)
+        bird_instance.start_date = child_instance.span.start_date - 1
+        bird_instance.save(validate: false)
+      end
+      it "the parent gains all children's errors" do
+        expect(
+          end_date_propagator.call.errors.values.join
+        ).to include(
+          I18n.t(
+            'not_within_parent_date_span',
+            parent: 'Child',
+            scope: %i[activerecord errors messages]
+          )
+        ).and include(
+          I18n.t(
+            'not_within_parent_date_span',
+            parent: 'Base',
+            scope: %i[activerecord errors messages]
+          )
+        )
+      end
+    end
+  end
+
+  describe '.call' do
+    subject(:result) do
+      ActsAsSpan::EndDatePropagator.call(obj, call_options)
+    end
+    let(:obj) { base_instance }
+
+    context 'when no skipped classes are passed' do
+      let(:call_options) { {} }
+
+      it 'forwards the correct arguments to :new' do
+        expect(ActsAsSpan::EndDatePropagator)
+          .to receive(:new).with(obj, call_options).and_call_original
+        expect(result).to eq(obj)
+      end
+    end
+
+    context 'when skipped classes are passed' do
+      let(:call_options) { { skipped_classes: ['bungus'] } }
+
+      it 'forwards the correct arguments to :new' do
+        expect(ActsAsSpan::EndDatePropagator)
+          .to receive(:new).with(obj, call_options).and_call_original
+        expect(result).to eq(obj)
+      end
+    end
+  end
+
+  describe '#call' do
+    context 'without an end_date' do
+      let(:object_instance) { SpannableModel.new }
+
+      it 'does not raise an error' do
+        expect do
+          ActsAsSpan::EndDatePropagator.new(object_instance).call
+        end.not_to raise_error
+      end
+    end
+
+    context 'updates children' do
+      before do
+        base_instance
+        base_instance.end_date = end_date
+      end
+
+      context 'base_instance.end_date nil -> !nil' do
+        let(:initial_end_date) { nil }
+        let(:end_date) { Date.current }
+
+        context 'child_end_date == initial_end_date' do
+          let(:child_end_date) { initial_end_date }
+
+          it 'propagates to the child_instance' do
+            expect{ end_date_propagator.call }.to change{
+              child_instance.reload.emancipation_date }
+              .from(child_end_date).to(base_instance.end_date)
+          end
+        end
+
+        context 'child_end_date >= initial_end_date' do
+          let(:child_end_date) { end_date + 3 }
+
+          it 'propagates to the child_instance' do
+            expect{ end_date_propagator.call }.to change{
+              child_instance.reload.emancipation_date}
+              .from(child_end_date).to(base_instance.end_date)
+          end
+        end
+
+        context 'child_end_date <= initial_end_date' do
+          let(:child_end_date) { end_date - 3 }
+
+          it 'does not propagate to the child_instance' do
+            expect{ end_date_propagator.call }.not_to change{
+              child_instance.reload.emancipation_date}
+          end
+        end
+
+        context 'when a child cannot have its end date updated' do
+          before do
+            # add a "within parent date span" error to child
+            base_instance.start_date = Date.current - 1
+            child_instance.date_of_birth = Date.current - 2
+            child_instance.save(validate: false)
+          end
+
+          it "the parent's end date is not updated" do
+            expect{ end_date_propagator.call }.to change{
+              base_instance.errors[:base]
+            }.from([])
+          end
+
+          context 'and the child is the child of a child' do
+            before do
+            end
+
+            it "the parent's end date is not updated" do
+              expect{ end_date_propagator.call }.not_to change{
+                base_instance.reload.end_date
+              }
+            end
+          end
+        end
+      end
+
+      context 'base_instance.end_date !nil -> nil' do
+        let(:initial_end_date) { Date.current }
+        let(:end_date) { nil }
+        let(:child_end_date) { initial_end_date }
+
+        it 'does not propagate to the child_instance' do
+          expect{ end_date_propagator.call }.not_to change{
+            child_instance.reload.emancipation_date }
+        end
+      end
+
+      context 'base_instance.end_date not changed' do
+        let(:end_date) { initial_end_date }
+
+        it 'does not propagate to the child_instance' do
+          expect{ end_date_propagator.call }.not_to change{
+            child_instance.reload.emancipation_date }
+        end
+      end
+
+      context 'has access to all children via has_many associations' do
+        let(:end_date) { Date.current }
+
+        it 'changes the end_date of all child associations' do
+          expect{ end_date_propagator.call }.to change{
+            child_instance.reload.emancipation_date }.
+            from(child_instance.emancipation_date).to(base_instance.end_date)
+            .and change{ dog_instance.reload.end_date }
+            .from(dog_instance.end_date).to(base_instance.end_date)
+            .and change{ bird_instance.reload.end_date }
+            .from(bird_instance.end_date).to(base_instance.end_date)
+        end
+      end
+    end
+
+    context 'when child record does not have end_date to update' do
+      let!(:cat_owner_instance) do
+        CatOwner.create(end_date: initial_end_date)
+      end
+      let!(:cat_instance) do
+        Cat.create(cat_owner: cat_owner_instance)
+      end
+      let(:cat_end_date) { nil }
+      let(:end_date) { Date.current }
+
+      before do
+        cat_owner_instance.end_date = end_date
+      end
+
+      it 'does not throw an error' do
+        expect(cat_instance).not_to respond_to(:end_date)
+        expect{ end_date_propagator.call }.not_to raise_error
+      end
+    end
+
+    context 'when a class is skipped' do
+      let(:end_date) { Date.current }
+      let(:skipped_classes) { [Tale] }
+
+      before do
+        base_instance
+        tale_instance.save!
+        base_instance.end_date = end_date
+      end
+
+      it 'does not propagate to that class' do
+        expect{ end_date_propagator.call }.not_to change{
+          tale_instance.reload.end_date }
+      end
+    end
+  end
+end

data/spec/lib/no_overlap_validator_spec.rb

@@ -69,7 +69,7 @@ RSpec.describe ActsAsSpan::NoOverlapValidator do
 
     before do
       all_siblings.each do |sibling|
-        sibling.update_attributes(papa: papa)
+        sibling.update(papa: papa)
       end
 
       new_child.papa = papa

data/spec/spec_models.rb

@@ -64,6 +64,8 @@ Temping.create :mama do
     t.date :end_date
   end
 
+  acts_as_span
+
   has_many :one_parent_children
   has_many :two_parent_children
 end
@@ -74,5 +76,116 @@ Temping.create :papa do
     t.date :end_date
   end
 
+  acts_as_span
+
   has_many :one_parent_children
 end
+
+# fulfill association requirements for EndDatePropagator
+Temping.create :base do
+  has_many :children, dependent: :destroy
+  has_many :dogs, dependent: :destroy
+  has_many :birds, through: :children
+  has_many :tales, dependent: :destroy
+
+  acts_as_span
+
+  with_columns do |t|
+    t.date :end_date
+    t.date :start_date
+  end
+end
+
+Temping.create :cat_owner do
+  has_many :cats, dependent: :destroy
+
+  acts_as_span
+
+  with_columns do |t|
+    t.date :start_date
+    t.date :end_date
+  end
+end
+
+Temping.create :cat do
+  belongs_to :cat_owner
+
+  with_columns do |t|
+    t.belongs_to :cat_owner
+  end
+end
+
+Temping.create :other_base do
+  has_many :children, dependent: :destroy
+
+  acts_as_span
+
+  with_columns do |t|
+    t.date :end_date
+    t.date :start_date
+  end
+end
+
+# has non-standard start_ and end_field names
+Temping.create :child do
+  belongs_to :base
+  belongs_to :other_base
+  has_many :birds, dependent: :destroy
+
+  validates_with ActsAsSpan::WithinParentDateSpanValidator,
+    parents: [:base]
+
+  acts_as_span(
+    start_field: :date_of_birth,
+    end_field: :emancipation_date
+  )
+
+  with_columns do |t|
+    t.date :date_of_birth
+    t.date :emancipation_date
+    t.string :manual_invalidation
+    t.belongs_to :base
+  end
+end
+
+Temping.create :dog do
+  belongs_to :base
+
+  acts_as_span
+
+  with_columns do |t|
+    t.date :start_date
+    t.date :end_date
+    t.belongs_to :base
+  end
+end
+
+
+Temping.create :bird do
+  belongs_to :child
+
+  validates_with ActsAsSpan::WithinParentDateSpanValidator,
+    parents: [:child]
+
+  acts_as_span
+
+  with_columns do |t|
+    t.date :end_date
+    t.date :start_date
+    t.belongs_to :child
+  end
+end
+
+Temping.create :tale do
+  belongs_to :base
+
+  acts_as_span
+
+  with_columns do |t|
+    t.date :end_date
+    t.date :start_date
+    t.belongs_to :base
+  end
+end
+
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_span
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Eric Sullivan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-12 00:00:00.000000000 Z
+date: 2020-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.6
+        version: '1.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.6
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: has_siblings
   requirement: !ruby/object:Gem::Requirement
@@ -145,13 +145,16 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".tool-versions"
 - ".travis.yml"
 - Gemfile
 - LICENSE
 - README.rdoc
 - Rakefile
 - acts_as_span.gemspec
+- config/locales/en/acts_as_span.yml
 - lib/acts_as_span.rb
+- lib/acts_as_span/end_date_propagator.rb
 - lib/acts_as_span/no_overlap_validator.rb
 - lib/acts_as_span/span_instance.rb
 - lib/acts_as_span/span_instance/status.rb
@@ -162,6 +165,7 @@ files:
 - lib/acts_as_span/within_parent_date_span_validator.rb
 - spec/lib/acts_as_span_spec.rb
 - spec/lib/delegation_spec.rb
+- spec/lib/end_date_propagator_spec.rb
 - spec/lib/no_overlap_validator_spec.rb
 - spec/lib/span_instance/named_scopes_on_spec.rb
 - spec/lib/span_instance/named_scopes_spec.rb
@@ -192,9 +196,21 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: acts_as_span 1.0.0
-test_files: []
+summary: acts_as_span 1.1.0
+test_files:
+- spec/lib/acts_as_span_spec.rb
+- spec/lib/delegation_spec.rb
+- spec/lib/end_date_propagator_spec.rb
+- spec/lib/no_overlap_validator_spec.rb
+- spec/lib/span_instance/named_scopes_on_spec.rb
+- spec/lib/span_instance/named_scopes_spec.rb
+- spec/lib/span_instance/overlap_spec.rb
+- spec/lib/span_instance/status_spec.rb
+- spec/lib/span_instance/validations_spec.rb
+- spec/lib/span_instance_spec.rb
+- spec/lib/within_parent_date_span_validator_spec.rb
+- spec/spec_helper.rb
+- spec/spec_models.rb