temporality 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8fd5d7006b68f06a13dd0f46790440a31d179384
+  data.tar.gz: f4e6b4354ede8fc9c0ad6fa8717fe0a6b080f290
+SHA512:
+  metadata.gz: d9dec839f133d29763adab32b68c017ecc12ef960398c8156c84f40e8bb4640c7161dcfa8d0e0f5268ff8e6d82ce7ed2b31e33bab330c3cbf979ada953a224ac
+  data.tar.gz: ecd202980a60ec146c429a45750dfffeff4337bb6aeac56c94f8a43aa4907f6fc058a59315587b850fcba471c670b4b253f3eedf72e557cd2052bc862b0a20fe

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2016 David FRANCOIS
+
+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,39 @@
+Temporality [![Build Status](https://secure.travis-ci.org/davout/temporality.png?branch=master)](http://travis-ci.org/davout/temporality) [![Coverage Status](https://img.shields.io/coveralls/davout/temporality.svg)](https://coveralls.io/r/davout/temporality?branch=master) [![Gem Version](https://badge.fury.io/rb/temporality.svg)](http://badge.fury.io/rb/temporality)
+=
+
+## What is Temporality
+Temporality adds the ability to `ActiveRecord::Base` descendants to validate temporal data on themselves, and their associations.
+
+## Target features
+- Completeness implique prevent_overlap! implique également d'être deferred jusqu'au commit de la transaction
+- Enforce this is only used on belong_to associations
+- Doit permettre de valider que le parent est rempli
+- Doit permettre au parent de valider que les enfants sont inclus
+- Doit ne pas permettre l'overlap des records enfants
+
+- Doit faire l'auto-close des records précédents, avec callbacks
+- Doit faire l'auto-close des enfants, avec callbacks
+- Doit permettre d'initialiser l'enfant avec les bornes du parent en faisant par exemple parent.children.build
+- Scopes AR : intersecting, contained, englobant
+- Quand les bornes du parent sont changées on doit jouer les validations de l'enfant, sinon dans les autres cas, c'est l'enfant qu'on valide
+- Que se passe-t-il quand on modifie les bornes du parent, mais qu'on modifie en même temps les bornes de l'enfant ?
+
+## Examples
+
+````ruby
+Temporality.configure do |config|
+  config.error_strategy = :exception
+end
+
+Temporality.configure do |config|
+  config.error_strategy = :active_model
+end
+
+class Contract < ActiveRecord::Base
+  has_many :compensations
+end
+
+class Compensation < ActiveRecord::Base
+  belongs_to :contract, temporality: { inclusion: true, auto_close_previous: true, allow_overlap: false, completeness: true }
+end
+````

data/lib/temporality/associations.rb

@@ -0,0 +1,29 @@
+module Temporality
+  module Associations
+
+    # TODO : Use class-inheritable instance variables
+
+    DEFAULTS = { inclusion: true, completeness: false, prevent_overlap: false, auto_close: false }
+
+    def belongs_to(*args, &block)
+      @temporality ||= {}
+      assoc_name = args.first
+
+      if args.last.is_a?(Hash)
+        if opts = args.last.delete(:temporality)
+          opts.keys.each do |key|
+            unless DEFAULTS.keys.include?(key)
+              raise "Unknown option '#{key}', valid options are #{DEFAULTS.keys.map(&:to_s).join(', ')}"
+            end
+          end
+
+          @temporality[assoc_name] = DEFAULTS.merge(opts)
+        end
+      end
+
+      super(*args, &block)
+    end
+
+  end
+end
+

data/lib/temporality/attribute_overrides.rb

@@ -0,0 +1,42 @@
+module Temporality
+
+  module AttributeOverrides
+
+    def starts_on
+      floor_to_temporal_infinity(super)
+    end
+
+    def ends_on
+      ceil_to_temporal_infinity(super)
+    end
+
+    def starts_on=(d)
+      super(floor_to_temporal_infinity(d))
+    end
+
+    def ends_on=(d)
+      super(ceil_to_temporal_infinity(d))
+    end
+
+    private
+
+    #
+    # Floors the parameter to `Temporality::PAST_INFINITY`
+    #
+    def floor_to_temporal_infinity(d)
+      [d, Temporality::PAST_INFINITY].compact.max
+    end
+
+    #
+    # Ceils the parameter to `Temporality::FUTURE_INFINITY`
+    #
+    def ceil_to_temporal_infinity(d)
+      [d, Temporality::FUTURE_INFINITY].compact.min
+    end
+
+
+
+  end
+
+end
+

data/lib/temporality/auto_close.rb

@@ -0,0 +1,11 @@
+require 'temporality/validation_strategy'
+
+module Temporality
+  class AutoClose < ValidationStrategy
+
+    def validate
+    end
+
+  end
+end
+

data/lib/temporality/completeness.rb

@@ -0,0 +1,21 @@
+require 'temporality/validation_strategy'
+
+module Temporality
+  class Completeness < ValidationStrategy
+
+    def validate
+      days = @model.day_count + (inverse.where('id <> ?', @model.id || -1).map(&:day_count).inject(&:+) || 0)
+      parent_days = @model.send(@assoc).day_count
+
+      raise Temporality::Violation.new(error_message) unless (parent_days == days)
+    end
+
+    def error_message
+      "#{@model.send(@assoc).class} record must have a temporally complete children collection for assocation #{inverse_name}"
+    end
+
+    # TODO : Check if in transaction ActiveRecord::Base.connection.open_transactions
+
+  end
+end
+

data/lib/temporality/day_count.rb

@@ -0,0 +1,10 @@
+module Temporality
+  module DayCount
+
+    def day_count
+      (ends_on - starts_on).to_i
+    end
+
+  end
+end
+

data/lib/temporality/default_boundary_values.rb

@@ -0,0 +1,15 @@
+module Temporality
+  module DefaultBoundaryValues
+
+    def self.included(base)
+      base.after_initialize :set_time_boundaries_defaults
+
+      def set_time_boundaries_defaults
+        self.starts_on = starts_on
+        self.ends_on = ends_on
+      end
+    end
+
+  end
+end
+

data/lib/temporality/inclusion.rb

@@ -0,0 +1,14 @@
+module Temporality
+  class Inclusion < ValidationStrategy
+
+    def validate
+      parent = @model.send(@assoc)
+
+      if parent && (parent.starts_on > @model.starts_on || parent.ends_on < @model.ends_on)
+        raise Temporality::Violation.new("Record of class #{self.class} is not temporally included in parent of class #{parent.class}, [#{@model.starts_on} - #{@model.ends_on}] is not included in [#{parent.starts_on} - #{parent.ends_on}]")
+      end
+    end
+
+  end
+end
+

data/lib/temporality/overlap.rb

@@ -0,0 +1,22 @@
+require 'temporality/validation_strategy'
+
+module Temporality
+  class Overlap < ValidationStrategy
+
+    def validate
+      overlapping = inverse.intersecting(@model)
+
+      if @model.id
+        overlapping = overlapping.where('id <> ?', @model.id)
+      end
+
+      raise Temporality::Violation.new(error_message) if overlapping.exists?
+    end
+
+    def error_message
+      "Found overlapping records for range [#{@model.starts_on} - #{@model.ends_on}]"
+    end
+
+  end
+end
+

data/lib/temporality/schema.rb

@@ -0,0 +1,33 @@
+#
+# Defines a `temporality` migration helper for use in a `create_table` block as well
+# as a `temporality(:table)` helper to be used to alter existing table definitions.
+#
+module Temporality
+  module Schema
+
+    def self.include_helpers!
+      if Object.const_defined?(:ActiveRecord)
+        ActiveRecord::Migration.send(:include, MigrationHelper)
+        ActiveRecord::ConnectionAdapters::TableDefinition.send(:include, TableDefinitionHelper)
+      end
+    end
+
+    module MigrationHelper
+      def temporality(table)
+        add_column(table, :starts_on, :date, null: false)
+        add_column(table, :ends_on, :date, null: false)
+      end
+    end
+
+    module TableDefinitionHelper
+      def temporality
+        date(:starts_on, null: false)
+        date(:ends_on, null: false)
+      end
+    end
+
+  end
+end
+
+Temporality::Schema.include_helpers!
+

data/lib/temporality/scopes.rb

@@ -0,0 +1,10 @@
+module Temporality
+  module Scopes
+
+    def intersecting(time_span)
+      where('starts_on <= ?', time_span.ends_on).where('ends_on >= ?', time_span.starts_on)
+    end
+
+  end
+end
+

data/lib/temporality/slice.rb

@@ -0,0 +1,27 @@
+require 'temporality/time_span'
+
+module Temporality
+  class Slice < TimeSpan
+    attr_accessor :value
+
+    def initialize(starts_on, ends_on, value)
+      @value = value
+      super(starts_on, ends_on)
+    end
+
+    def to_s
+      "(SL : #{super} -> #{@value})"
+    end
+
+    def intersect(time_span)
+      if time_span.is_a? TimeSpan
+        intersects?(time_span) ? Slice.new([@starts_on, time_span.starts_on].max, [@ends_on, time_span.ends_on].min, @value) : nil
+      elsif time_span.is_a? SliceCollection
+        r = time_span.map { |s| intersect s }.compact
+        r.size > 1 ? SliceCollection.new(s) : s
+      else
+        raise TypeError, 'Argument should be a TimeSpan or a SliceCollection'
+      end
+    end
+  end
+end

data/lib/temporality/slice_collection.rb

@@ -0,0 +1,82 @@
+require 'temporality/time_span_collection'
+require 'temporality/slice'
+
+module Temporality
+  class SliceCollection < TimeSpanCollection
+    attr_accessor :slices
+
+    def initialize(values = nil)
+      collection_from_history(values) if values
+    end
+
+    def to_s
+      "{SLC : #{map(&:to_s) .join(', ')}}"
+    end
+
+    # TODO : Méthodes nécessaires ?
+    # def starts_on
+    #   first.starts_on unless empty?
+    # end
+
+    # def ends_on
+    #   last.ends_on unless empty?
+    # end
+
+    # Remplit les 'trous' d'une collection de slices par rapport à un time_span de référence
+    # en utilisant les valeurs disponibles dans la collection de slices passée en paramètre
+    def fill_missing_with!(slices, time_span)
+      self << slices.intersect(time_span.substract(self))
+      flatten!
+      sort!
+    end
+
+    def value_for(time_span)
+      detect do |slice|
+        slice.covers? time_span
+      end.value
+    end
+
+    def intersect(tsc)
+      if tsc.is_a? TimeSpanCollection
+        tsc.inject(SliceCollection.new) do |r, s|
+          r << intersect(s)
+        end.compact.sort
+      elsif tsc.is_a? TimeSpan
+        map { |s| s.intersect tsc }.compact
+      end
+    end
+
+    private
+
+    def collection_from_history(values)
+      sorted_values = values.sort do |a, b|
+        a.starts_on <=> b.starts_on
+      end
+
+      previous_slice = nil
+
+      sorted_values.each_with_index do |v, _i|
+        slice = Slice.new(v.starts_on, v.ends_on, v.value)
+
+        if previous_slice
+          raise 'Overlapping slices!' if slice.starts_on <= previous_slice.ends_on
+          not_period_complete! if previous_slice.ends_on.advance(days: 1) < slice.starts_on
+        end
+
+        self.<<(slice)
+      end
+    end
+
+    def self.not_period_complete!
+      raise 'Not period complete'
+    end
+
+    def <=>(slice_collection)
+      (size == slice_collection.slices.size) && all? { |slice| slice_collection.include?(slice) }
+    end
+
+    def method_missing(_method, *_args)
+      raise SlicedConceptInterrupt
+    end
+  end
+end

data/lib/temporality/time_span.rb

@@ -0,0 +1,127 @@
+module Temporality
+  class TimeSpan
+    include Comparable
+
+    attr_accessor :starts_on, :ends_on
+
+    def initialize(starts_on, ends_on, _options = {})
+      @starts_on = starts_on
+      @ends_on = ends_on
+
+      check!
+    end
+
+    def to_s
+      "{ TS : [#{starts_on} | #{ends_on}]}"
+    end
+
+    def inspect
+      to_s
+    end
+
+    # TODO : Refactorer éventuellement pour avoir un algo ~o(1) au lieu de o(n)
+    # Utiliser Date#ld comme base pour un algo ~o(1)
+    def day_count(excluded = [])
+      if excluded.empty?
+        1 + (@ends_on - @starts_on).to_i
+      else
+        (@starts_on..@ends_on).inject(0) { |c, day| c += excluded.include?(day.cwday) ? 0 : 1 }
+      end
+    end
+
+    def calendaires
+      day_count
+    end
+
+    def ouvres
+      day_count [6, 7]
+    end
+
+    def ouvrables
+      day_count [7]
+    end
+
+    def covers?(time_span)
+      (@starts_on <= time_span.starts_on) && (@ends_on >= time_span.ends_on)
+    end
+
+    def ==(time_span)
+      @starts_on == time_span.starts_on && @ends_on == time_span.ends_on
+    end
+
+    def eql?(time_span)
+      self.==(time_span) && (self.class == time_span.class)
+    end
+
+    def <=>(time_span)
+      if @starts_on != time_span.starts_on
+        @starts_on <=> time_span.starts_on
+      else
+        @ends_on <=> time_span.ends_on
+      end
+    end
+
+    def intersects?(time_span)
+      if time_span.respond_to?(:starts_on) && time_span.respond_to?(:ends_on)
+        (time_span.ends_on >= @starts_on) && (time_span.starts_on <= @ends_on)
+      elsif time_span.is_a?(TimeSpanCollection)
+        time_span.any? { |ts| intersects? ts }
+      end
+    end
+
+    def intersect(time_span)
+      if time_span.is_a? TimeSpan
+        intersects?(time_span) ? TimeSpan.new([@starts_on, time_span.starts_on].max, [@ends_on, time_span.ends_on].min) : nil
+      elsif time_span.is_a? TimeSpanCollection
+        # byebug
+        r = time_span.map { |ts| intersect ts }.compact
+        r.size > 1 ? TimeSpanCollection.new(r) : r.first
+      end
+    end
+
+    def substract(time_span)
+      if time_span.is_a?(TimeSpan)
+        if time_span.covers? self
+          nil
+        elsif !time_span.intersects? self
+          dup
+        elsif starts_on < time_span.starts_on && ends_on > time_span.ends_on
+          TimeSpanCollection.new([
+            TimeSpan.new(starts_on, time_span.starts_on - 1),
+            TimeSpan.new(time_span.ends_on + 1, ends_on)
+          ])
+        elsif starts_on < time_span.starts_on && ends_on <= time_span.ends_on
+          TimeSpan.new(starts_on, time_span.starts_on - 1)
+        elsif starts_on >= time_span.starts_on && ends_on > time_span.ends_on
+          TimeSpan.new(time_span.ends_on + 1, ends_on)
+        else
+          raise "That's one fucked up edge case"
+        end
+      elsif time_span.is_a?(TimeSpanCollection)
+        TimeSpanCollection.new(
+          time_span.inject(dup) do |res, ts|
+            res.substract(ts)
+          end
+        )
+      else
+        raise TypeError, 'Wrong type supplied, should be TimeSpan or TimeSpanCollection'
+      end
+    end
+
+    def intersect!(time_span)
+      @starts_on = [@starts_on, time_span.starts_on].max
+      @ends_on = [@ends_on, time_span.ends_on].min
+      check!
+    end
+
+    private
+
+    def valid?
+      @starts_on <= @ends_on
+    end
+
+    def check!
+      raise "Invalid dates : #{self}" unless valid?
+    end
+  end
+end

data/lib/temporality/time_span_collection.rb

@@ -0,0 +1,61 @@
+require 'temporality/time_span'
+
+module Temporality
+  class TimeSpanCollection < Array
+    def initialize(collection = [])
+      super()
+      collection = [collection].flatten # Support pour ne passer qu'un seul TS
+      collection.map { |ts| self << (ts.is_a?(TimeSpan) ? ts : raise(TypeError, "Element is not a Temporality::TimeSpan")) }
+      sort!
+    end
+
+    def to_s
+      "{TSC : #{map { |ts| ts.to_s }.join(", ")}}"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def limit_to!(time_span)
+      reject! { |ts| !ts.intersects?(time_span) }
+      first.starts_on = [first.starts_on, time_span.starts_on].max
+      last.ends_on = [last.ends_on, time_span.ends_on].min
+      self
+    end
+
+    def intersect!(time_span)
+      if time_span.is_a? TimeSpan
+        map! { |ts| ts.intersect(time_span) }.compact!
+      elsif time_span.is_a? TimeSpanCollection
+        raise 'Not handling time_span collections yet'
+      else
+        raise TypeError, "Element is not a Temporality::TimeSpan or a Temporality::TimeSpanCollection"
+      end
+
+      self
+    end
+
+    def intersect(tsc)
+      res = tsc.inject(TimeSpanCollection.new) do |r, ts|
+        r << ts.intersect(self)
+      end.compact.sort
+
+      TimeSpanCollection.new(res)
+    end
+
+    def intersects?(time_span)
+      any? { |ts| ts.intersects? time_span }
+    end
+
+    def substract(time_span)
+      raise TypeError, "Not a TimeSpan" unless time_span.is_a? TimeSpan
+
+      TimeSpanCollection.new(
+        map do |ts|
+          ts.substract(time_span)
+        end
+      )
+    end
+  end
+end

data/lib/temporality/validation.rb

@@ -0,0 +1,54 @@
+require 'temporality/violation'
+
+require 'temporality/auto_close'
+require 'temporality/completeness'
+require 'temporality/overlap'
+require 'temporality/inclusion'
+
+module Temporality
+  module Validation
+
+    VALIDATIONS = {
+      inclusion:        Inclusion,
+      prevent_overlap:  Overlap,
+      completeness:     Completeness,
+      auto_close:       AutoClose
+    }
+
+    DEFAULTS = { inclusion: true, completeness: false, prevent_overlap: false, auto_close: false }
+
+    def valid?(*args, &block)
+      validate_temporality_contraints!
+      super(*args, &block)
+    end
+
+
+    private
+
+    def validate_temporality_contraints!
+      validate_bounds_order
+
+      temporal_associations.each do |assoc, constraints|
+        constraints.select { |k,v| v }.keys.each do |constraint|
+          validate_constraint(assoc, constraint)
+        end
+      end
+    end
+
+    def validate_constraint(assoc, constraint)
+      VALIDATIONS[constraint].new(self, assoc).validate
+    end
+
+    def validate_bounds_order
+      if starts_on > ends_on
+        raise Temporality::Violation.new("Start date is after end date [#{starts_on} - #{ends_on}]")
+      end
+    end
+
+    def temporal_associations
+      self.class.instance_variable_get(:@temporality) || {}
+    end
+
+  end
+end
+

data/lib/temporality/validation_strategy.rb

@@ -0,0 +1,23 @@
+module Temporality
+  class ValidationStrategy
+
+    def initialize(model, assoc)
+      @model = model
+      @assoc = assoc
+    end
+
+
+    protected
+
+    def inverse
+      raise "Unable to validate temporality overlap for #{@model.class} without inverse for association '#{@assoc}'" unless inverse_name
+      @model.send(@assoc).send(inverse_name)
+    end
+
+    def inverse_name
+      @model.class.reflect_on_association(@assoc).send(:inverse_name)
+    end
+
+  end
+end
+

data/lib/temporality/version.rb

@@ -0,0 +1,7 @@
+module Temporality
+
+  # Temporality gem version
+  VERSION = '0.0.4'
+
+end
+

data/lib/temporality/violation.rb

@@ -0,0 +1,5 @@
+module Temporality
+  class Violation < RuntimeError
+  end
+end
+

data/lib/temporality.rb

@@ -0,0 +1,36 @@
+require 'date'
+
+require 'temporality/version'
+
+require 'temporality/slice_collection'
+
+require 'temporality/validation'
+require 'temporality/default_boundary_values'
+require 'temporality/attribute_overrides'
+require 'temporality/associations'
+require 'temporality/schema'
+require 'temporality/scopes'
+require 'temporality/day_count'
+
+module Temporality
+
+  # Used when no start date is defined
+  PAST_INFINITY = Date.new(1500, 1, 1)
+
+  # Used when no end date is defined
+  FUTURE_INFINITY = Date.new(5000, 1, 1)
+
+  PREPENDS  = [ AttributeOverrides, Validation ]
+  EXTENDS   = [ Associations, Scopes ]
+  INCLUDES  = [ DefaultBoundaryValues ]
+
+  def self.included(base)
+    PREPENDS.each { |mod| base.prepend(mod) }
+    EXTENDS.each  { |mod| base.extend(mod) }
+    INCLUDES.each { |mod| base.include(mod) }
+
+    ActiveRecord::Base.send(:include, DayCount)
+  end
+
+end
+

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: temporality
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- David FRANCOIS
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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: sqlite3
+  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: byebug
+  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: Give records the ability to validate temporal constraints on themselves
+  and associations
+email:
+- david@paygun.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/temporality.rb
+- lib/temporality/associations.rb
+- lib/temporality/attribute_overrides.rb
+- lib/temporality/auto_close.rb
+- lib/temporality/completeness.rb
+- lib/temporality/day_count.rb
+- lib/temporality/default_boundary_values.rb
+- lib/temporality/inclusion.rb
+- lib/temporality/overlap.rb
+- lib/temporality/schema.rb
+- lib/temporality/scopes.rb
+- lib/temporality/slice.rb
+- lib/temporality/slice_collection.rb
+- lib/temporality/time_span.rb
+- lib/temporality/time_span_collection.rb
+- lib/temporality/validation.rb
+- lib/temporality/validation_strategy.rb
+- lib/temporality/version.rb
+- lib/temporality/violation.rb
+homepage: https://paygun.fr
+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: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Make records temporal
+test_files: []