activerecord-bitemporal 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3801f30411bb5e26d32aa1cb27ed45e5c12ebea99b688fcc27b9be1289099fc
-  data.tar.gz: a1ef742f3e2b7c8cb3bd280ba0fb92a5f1f45b2504fc29dc7b789d2694c2b284
+  metadata.gz: 712d3f7bf1cb73ff98bbe7f5ca15f860c62096e419b89d44e6a419ba865eec38
+  data.tar.gz: 4071219bd39db37fc51dee4d1689f722c0a8c2ee6eb16120373d21ecf234def8
 SHA512:
-  metadata.gz: 48b484ead6164bd5784a9060085267e7b6b9ae80a23f5015177ed45e4e82e702634731b2bb90a5ac67018c6d3052edf6839095327bc22bfbab98d412a013f279
-  data.tar.gz: 004c5991bcebf4079b98665fb295d45cb473ebf2f83f0cdbf4ca08770003e7f4cf38f969b18e8d265fe2b39e3621ae5201953396dcecf9a79010f55c875be1b4
+  metadata.gz: fb0f10288f109171dd11aed5221fe0297224c6d798278ba60c18cad092cf4b757d2c5aff9463c9a9fafe0f1556f1d71d47d4d89d435f96f8debdda51883c0e42
+  data.tar.gz: 588eb1741174be2031b8e326fe34da93efebda700ad37bb26a260250a3e25d6b1ecb3ffc1964a7fb99c8ea4035d4a660e59ec617d5732320f944467a3d71b202

data/CHANGELOG.md

@@ -1,39 +1,37 @@
 # Changelog
 
-## Unreleased
+## 2.0.0
 
-### Breaking Changes
-
-- [#15](https://github.com/kufu/activerecord-bitemporal/pull/15) - `validates :bitemporal_id, uniqueness: true` is no raise by default.
-- [#19](https://github.com/kufu/activerecord-bitemporal/pull/19) - Fix create history records after logical destroy in #destroy.
+### Breaking Changed
+- [[Proposal] Changed valid_in to exclude valid_from = to and valid_to = from. by osyo-manga · Pull Request #95](https://github.com/kufu/activerecord-bitemporal/pull/95)
 
 ### Added
 
-- [#12](https://github.com/kufu/activerecord-bitemporal/pull/12) - Added utility (and extension) scopes.
-  - `.bitemporl_for(id)`
-  - `.valid_in(from: from, to: to)`
-  - `.valid_allin(from: from, to: to)`
-  - `.bitemporal_histories_by(id)`
-  - `.bitemporal_most_future(id)`
-  - `.bitemporal_most_past(id)`
-- [#15](https://github.com/kufu/activerecord-bitemporal/pull/15) - Added `.bitemporalize`. Use `.bitemporalize` instead of `include ActiveRecord::Bitemporal`.
-- [#15](https://github.com/kufu/activerecord-bitemporal/pull/15) - Added `.bitemporalize` options.
+### Changed
+- [[Proposal] Add range argument to .valid_allin. by Dooor · Pull Request #98](https://github.com/kufu/activerecord-bitemporal/pull/98)
 
-| option | describe | default |
-| --- | --- | --- |
-| `enable_strict_by_validates_bitemporal_id` | raised with `validates :bitemporal_id, uniqueness: true` if `true` | false |
+### Deprecated
 
+### Removed
 
 ### Fixed
+- [Fix JOIN query does not have valid_from / valid_to when using .or. by osyo-manga · Pull Request #99](https://github.com/kufu/activerecord-bitemporal/pull/99)
+- [Fix typo in README.md by Naoya9922 · Pull Request #101](https://github.com/kufu/activerecord-bitemporal/pull/101)
+
+## 1.1.0
+
+### Added
 
-- [#17](https://github.com/kufu/activerecord-bitemporal/pull/17) - Fixed bug in create record with valid_datetime out of the range valid_from to valid_to.
-- [#18](https://github.com/kufu/activerecord-bitemporal/pull/18) - `record.valid_datetime` is not nil when after `Model.valid_at("2019/1/1").ignore_valid_datetime`.
-- [#18](https://github.com/kufu/activerecord-bitemporal/pull/18) - `ignore_valid_datetime` is not applied in `ActiveRecord::Bitemporal.valid_at!`.
-- [#21](https://github.com/kufu/activerecord-bitemporal/pull/21) - Fixed bug in multi thread with `#update`.
-- [#24](https://github.com/kufu/activerecord-bitemporal/pull/24) [#25](https://github.com/kufu/activerecord-bitemporal/pull/25) - Fixed bug. Does not respect table alias on join clause.
-- [#27](https://github.com/kufu/activerecord-bitemporal/pull/27) - Fixed a bug that `swapped_id` doesn't change after `#reload`.
-- [#28](https://github.com/kufu/activerecord-bitemporal/pull/28) - Fix the bug that `valid_from == valid_to` record is generated.
+- [Add bitemporal data structure visualizer by wata727 · Pull Request #94](https://github.com/kufu/activerecord-bitemporal/pull/94)
+
+### Changed
 
 ### Deprecated
 
-- None
+### Removed
+
+### Fixed
+
+## 1.0.0
+
+First stable release

data/README.md

@@ -195,7 +195,7 @@ end
 | `valid_from` | `datetime` | 有効時間の開始時刻 |
 | `valid_to` | `datetime` | 有効時間の終了時刻 |
 | `transaction_from` | `datetime` | システム時間の開始時刻 |
-| `transaction_to` | `datetime` | システム時間の終了終了 |
+| `transaction_to` | `datetime` | システム時間の終了時刻 |
 
 また、モデルクラスでは `ActiveRecord::Bitemporal` を `include` をする必要があります。
 

data/activerecord-bitemporal.gemspec

@@ -7,8 +7,8 @@ require "activerecord-bitemporal/version"
 Gem::Specification.new do |spec|
   spec.name          = "activerecord-bitemporal"
   spec.version       = ActiveRecord::Bitemporal::VERSION
-  spec.authors       = ["mserizawa"]
-  spec.email         = ["serizawa@smarthr.co.jp"]
+  spec.authors       = ["SmartHR"]
+  spec.email         = ["oss@smarthr.co.jp"]
 
   spec.summary       = "BiTemporal Data Model for ActiveRecord"
   spec.description   = %q{Enable ActiveRecord models to be handled as BiTemporal Data Model.}

data/lib/activerecord-bitemporal/scope.rb

@@ -47,7 +47,7 @@ module ActiveRecord::Bitemporal
           end
         }
 
-        def each_operatable_node(nodes = predicates, &block)
+        def each_operatable_node_6_0(nodes = predicates, &block)
           if block
             each_operatable_node(nodes).each(&block)
           else
@@ -56,11 +56,6 @@ module ActiveRecord::Bitemporal
                 case node
                 when Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
                   y << node if node && node.left.respond_to?(:relation)
-                when Arel::Nodes::Or, Arel::Nodes::And
-                  if Gem::Version.new("6.1.0") <= ActiveRecord.version
-                    each_operatable_node(node.left) { |node| y << node }
-                    each_operatable_node(node.right) { |node| y << node }
-                  end
                 when Arel::Nodes::Grouping
                   each_operatable_node(node.expr) { |node| y << node }
                 end
@@ -69,6 +64,36 @@ module ActiveRecord::Bitemporal
           end
         end
 
+        def each_operatable_node_6_1(nodes = predicates, &block)
+          if block
+            each_operatable_node_6_1(nodes).each(&block)
+          else
+            Enumerator.new { |y|
+              Array(nodes).each { |node|
+                case node
+                when Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
+                  y << node if node && node.left.respond_to?(:relation)
+                when Arel::Nodes::And
+                  each_operatable_node_6_1(node.children) { |node| y << node }
+                when Arel::Nodes::Binary
+                  each_operatable_node_6_1(node.left) { |node| y << node }
+                  each_operatable_node_6_1(node.right) { |node| y << node }
+                when Arel::Nodes::Unary
+                  each_operatable_node_6_1(node.expr) { |node| y << node }
+                end
+              }
+            }
+          end
+        end
+
+        def each_operatable_node(nodes = predicates, &block)
+          if Gem::Version.new("6.1.0") <= ActiveRecord.version
+            each_operatable_node_6_1(nodes, &block)
+          else
+            each_operatable_node_6_0(nodes, &block)
+          end
+        end
+
         def bitemporal_query_hash(*names)
           each_operatable_node
             .select { |node| names.include? node.left.name.to_s }
@@ -466,15 +491,53 @@ module ActiveRecord::Bitemporal
         where(bitemporal_id: id)
       }
 
-      scope :valid_in, -> (from: nil, to: nil) {
-        ignore_valid_datetime
-          .tap { |relation| break relation.bitemporal_where_bind("valid_to", :gteq, from.in_time_zone.to_datetime) if from }
-          .tap { |relation| break relation.bitemporal_where_bind("valid_from", :lteq, to.in_time_zone.to_datetime) if to }
+      # from < valid_to AND valid_from < to
+      scope :valid_in, -> (range = nil, from: nil, to: nil) {
+        return valid_in(from...to) if range.nil?
+
+        relation = ignore_valid_datetime
+        begin_, end_ = range.begin, range.end
+
+        # beginless range
+        if begin_
+          # from < valid_to
+          relation = relation.bitemporal_where_bind("valid_to", :gt, begin_.in_time_zone.to_datetime)
+        end
+
+        # endless range
+        if end_
+          if range.exclude_end?
+            # valid_from < to
+            relation = relation.bitemporal_where_bind("valid_from", :lt, end_.in_time_zone.to_datetime)
+          else
+            # valid_from <= to
+            relation = relation.bitemporal_where_bind("valid_from", :lteq, end_.in_time_zone.to_datetime)
+          end
+        end
+
+        relation
       }
-      scope :valid_allin, -> (from: nil, to: nil) {
-        ignore_valid_datetime
-          .tap { |relation| break relation.bitemporal_where_bind("valid_from", :gteq, from.in_time_zone.to_datetime) if from }
-          .tap { |relation| break relation.bitemporal_where_bind("valid_to", :lteq, to.in_time_zone.to_datetime) if to }
+
+      # from <= valid_from AND valid_to <= to
+      scope :valid_allin, -> (range = nil, from: nil, to: nil) {
+        return valid_allin(from..to) if range.nil?
+
+        relation = ignore_valid_datetime
+        begin_, end_ = range.begin, range.end
+
+        if begin_
+          relation = relation.bitemporal_where_bind("valid_from", :gteq, begin_.in_time_zone.to_datetime)
+        end
+
+        if end_
+          if range.exclude_end?
+            raise 'Range with excluding end is not supported'
+          else
+            relation = relation.bitemporal_where_bind("valid_to", :lteq, end_.in_time_zone.to_datetime)
+          end
+        end
+
+        relation
       }
     end
 

data/lib/activerecord-bitemporal/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module Bitemporal
-    VERSION = "1.0.0"
+    VERSION = "2.0.0"
   end
 end

data/lib/activerecord-bitemporal/visualizer.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module ActiveRecord::Bitemporal
+  module Visualizer
+    # Figure is a two-dimensional array holding plotted lines and columns
+    class Figure < Array
+      def print(str, line: 0, column: 0)
+        self[line] ||= []
+        str.each_char.with_index(column) do |c, i|
+          # The `#` represents a zero-length rectangle and should not be overwritten with lines
+          next if self[line][i] == '#' && (c == '+' || c == '|' || c == '-')
+
+          self[line][i] = c
+        end
+      end
+
+      def to_s
+        map { |l| l&.map { |c| c || ' ' }&.join }.join("\n")
+      end
+    end
+
+    module_function
+
+    def visualize(record, height: 10, width: 40, highlight: true)
+      histories = record.class.ignore_bitemporal_datetime.bitemporal_for(record).order(:transaction_from, :valid_from)
+
+      if highlight
+        visualize_records(histories, [record], height: height, width: width)
+      else
+        visualize_records(histories, height: height, width: width)
+      end
+    end
+
+    # e.g. visualize_records(ActiveRecord::Relation, ActiveRecord::Relation)
+    def visualize_records(*relations, height: 10, width: 40)
+      raise 'More than 3 relations are not supported' if relations.size >= 3
+      records = relations.flatten
+
+      valid_times = (records.map(&:valid_from) + records.map(&:valid_to)).sort.uniq
+      transaction_times = (records.map(&:transaction_from) + records.map(&:transaction_to)).sort.uniq
+  
+      time_length = Time.zone.now.strftime('%F %T.%3N').length
+  
+      columns = compute_positions(valid_times, length: width, left_margin: time_length + 1, outlier: ActiveRecord::Bitemporal::DEFAULT_VALID_TO)
+      lines = compute_positions(transaction_times, length: height, outlier: ActiveRecord::Bitemporal::DEFAULT_TRANSACTION_TO)
+  
+      headers = Figure.new
+      valid_times.each_with_object([]).with_index do |(valid_time, prev_valid_times), line|
+        prev_valid_times.each do |valid_time|
+          headers.print('|', line: line, column: columns[valid_time])
+        end
+        headers.print("| #{valid_time.strftime('%F %T.%3N')}", line: line, column: columns[valid_time])
+        prev_valid_times << valid_time
+      end
+  
+      body = Figure.new
+      relations.each.with_index do |relation, idx|
+        filler = idx == 0 ? ' ' : '*'
+
+        relation.each do |record|
+          line = lines[record.transaction_from]
+          column = columns[record.valid_from]
+    
+          width = columns[record.valid_to] - columns[record.valid_from] - 1
+          height = lines[record.transaction_to] - lines[record.transaction_from] - 1
+    
+          body.print("#{record.transaction_from.strftime('%F %T.%3N')} ", line: line)
+          if width > 0
+            if height > 0
+              body.print('+' + '-' * width + '+', line: line, column: column)
+            else
+              body.print('|' + '#' * width + '|', line: line, column: column)
+            end
+          else
+            body.print('#', line: line, column: column)
+          end
+
+          1.upto(height) do |i|
+            if width > 0
+              body.print('|' + filler * width + '|', line: line + i, column: column)
+            else
+              body.print('#', line: line + i, column: column)
+            end
+          end
+
+          body.print("#{record.transaction_to.strftime('%F %T.%3N')} ", line: line + height + 1)
+          if width > 0
+            body.print('+' + '-' * width + '+', line: line + height + 1, column: column)
+          else
+            body.print('#', line: line + height + 1, column: column)
+          end
+        end
+      end
+  
+      "#{headers.to_s}\n#{body.to_s}"
+    end
+  
+    # Compute a dictionary of where each time should be plotted.
+    # The position is normalized to the actual length of time.
+    #
+    # Example:
+    #
+    #   t1     t2     t3                t4
+    #   |------|------|-----------------|
+    #
+    #   f(t1, t2, t3, t4) -> { t1 => 0, t2 => 2, t3 => 4, t4 => 10 }
+    #
+    def compute_positions(times, length:, left_margin: 0, outlier: nil)
+      lengths_from_beginning = compute_lengths_from_beginning(times, outlier: outlier)
+      # times must be sorted in ascending order. This is caller's responsibility.
+      # In that case, the last of lengths_from_beginning is equal to the total length.
+      total = lengths_from_beginning.values.last
+  
+      times.each_with_object({}) do |time, ret|
+        prev = ret.values.last
+        pos = (lengths_from_beginning[time] / total * length).to_i + left_margin
+  
+        if prev
+          # If the difference of times is too short, a position that have already been plotted may be computed.
+          # But we still want to plot the time, so allocate the required number to plot the smallest area.
+          if pos <= prev
+            # | -> |*|
+            #       ^^ 2 columns
+            pos = prev + 2
+          elsif pos == prev + 1
+            # || -> |*|
+            #        ^ 1 column
+            pos += 1
+          end
+        end
+        ret[time] = pos
+      end
+    end
+  
+    # Example:
+    #
+    #   t1          t2          t3          t4
+    #   |-----------|-----------|-----------|
+    #   <-----------> l1
+    #   <-----------------------> l2
+    #   <-----------------------------------> l3
+    #
+    #   f([t1, t2, t3, t4]) -> { t1 => 0, t2 => l1, t3 => l2, t4 => l3 }
+    #
+    def compute_lengths_from_beginning(times, outlier: nil)
+      times.each_with_object({}) do |time, ret|
+        ret[time] = if time == outlier && times.size > 2
+                      # If it contains an extremely large value such as 9999-12-31,
+                      # that point will have a large effect on the visualization,
+                      # so adjust the length so that it is half of the whole.
+                      ret.values.last * 2
+                    else
+                      time - times.min
+                    end
+      end
+    end
+  end
+end

data/lib/activerecord-bitemporal.rb

@@ -6,6 +6,7 @@ require "activerecord-bitemporal/bitemporal"
 require "activerecord-bitemporal/scope"
 require "activerecord-bitemporal/patches"
 require "activerecord-bitemporal/version"
+require "activerecord-bitemporal/visualizer"
 
 module ActiveRecord::Bitemporal
   DEFAULT_VALID_FROM = Time.utc(1900, 12, 31).in_time_zone.freeze

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-bitemporal
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
-- mserizawa
+- SmartHR
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-12 00:00:00.000000000 Z
+date: 2022-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -138,7 +138,7 @@ dependencies:
         version: '0'
 description: Enable ActiveRecord models to be handled as BiTemporal Data Model.
 email:
-- serizawa@smarthr.co.jp
+- oss@smarthr.co.jp
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -168,6 +168,7 @@ files:
 - lib/activerecord-bitemporal/patches.rb
 - lib/activerecord-bitemporal/scope.rb
 - lib/activerecord-bitemporal/version.rb
+- lib/activerecord-bitemporal/visualizer.rb
 homepage: https://github.com/kufu/activerecord-bitemporal
 licenses:
 - Apache 2.0
@@ -187,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: BiTemporal Data Model for ActiveRecord