logidze 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17de700c04926cec63c3498e6568b889cfd240b9
-  data.tar.gz: 3dd305a8537eec34a7c68f0c318b9150b162205d
+  metadata.gz: c8e3b2e4793fe16e96a40e2059df0b137be3a6b0
+  data.tar.gz: 96bdab4a164cdb0180d6b91b602b1d5831245512
 SHA512:
-  metadata.gz: bc4e0b72623d6d7419e444c973ea01138eccd9b41e21a4712323f2ee2a88df5389fa13acc7ad9be00d96e50b272c7c2ab3d98e85f180f96c294b0f834a8cebf1
-  data.tar.gz: 12c1f0cb5e81aba650a91a840a1911831219c8f5a9c972024f976d8369abd277156851212c5c4ce6ef143e9fe359e44ee6576e9b2b79e00083da1b01a717fd9b
+  metadata.gz: 6b5eccd3de9563162195ca6e8350ed3136a696085485bdd95a806e6eef449b2d76b9690b4aea6558773d39df321be5bbb8998b97f5461907763643bb7f8800e2
+  data.tar.gz: 1b1389f59b82cb3fc637151e3c8561cea387a7d83a58dbf93805d619916b34ca0a682e0be54d88bb934ff4caa1697d2ed2986167837234fdf36f8d6513844a4b

data/.rubocop.yml

@@ -23,7 +23,7 @@ Style/Documentation:
   Exclude:
     - 'spec/**/*.rb'
 
-Style/StringLiterals: 
+Style/StringLiterals:
   Enabled: false
 
 Style/SpaceInsideStringInterpolation:
@@ -49,4 +49,15 @@ Rails/Date:
   Enabled: false
 
 Rails/TimeZone:
-  Enabled: false
+  Enabled: false
+
+Style/NumericLiteralPrefix:
+  Enabled: false
+
+Lint/HandleExceptions:
+  Enabled: true
+  Exclude:
+    - 'spec/**/*.rb'
+
+Style/DotPosition:
+  EnforcedStyle: leading

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Change log
 
+## 0.5.0 (2017-03-28)
+
+- Add an option to preserve future versions. ([@akxcv][])
+
+- Add `--timestamp_column` option to model migration generator. ([@akxcv][])
+
+- Default version timestamp to timestamp column. ([@akxcv][])
+
+- Associations versioning. ([@charlie-wasp][])
+
 ## 0.4.1 (2017-02-06)
 
 - Add `--path` option to model migration generator. ([@palkan][])
@@ -36,3 +46,4 @@
 
 [@palkan]: https://github.com/palkan
 [@charlie-wasp]: https://github.com/charlie-wasp
+[@akxcv]: https://github.com/akxcv

data/README.md

@@ -75,6 +75,20 @@ By default, Logidze tries to infer the path to the model file from the model nam
 rails generate logidze:model Post --path "app/models/custom/post.rb"
 ```
 
+By default, Logidze tries to get a timestamp for a version from record's `updated_at` field whenever appropriate. If
+your model does not have that column, Logidze will gracefully fall back to `statement_timestamp()`.
+To change the column name or disable this feature completely, you can use the `timestamp_column` option:
+
+```ruby
+# will try to get the timestamp value from `time` column
+rails generate logidze:model Post --timestamp_column time
+# will always set version timestamp to `statement_timestamp()`
+rails generate logidze:model Post --timestamp_column nil # "null" and "false" will also work
+```
+
+Logidze also supports associations versioning. It is experimental feature, and disabled by default. You can learn more
+in the [wiki](https://github.com/palkan/logidze/wiki/Associations-versioning).
+
 ## Troubleshooting
 
 The most common problem is `"permission denied to set parameter "logidze.xxx"` caused by `ALTER DATABASE ...` query.
@@ -157,7 +171,24 @@ post.redo!
 post.switch_to!(2)
 ```
 
-If you update record after `#undo!` or `#switch_to!` you lose all "future" versions and `#redo!` is no longer possible.
+Normally, if you update record after `#undo!` or `#switch_to!` you lose all "future" versions and `#redo!` is no
+longer possible. However, you can provide an `append: true` option to `#undo!` or `#switch_to!`, which will
+create a new version with old data. Caveat: when switching to a newer version, `append` will have no effect.
+
+```ruby
+post = Post.create!(title: 'first post') # v1
+post.update!(title: 'new title')         # v2
+post.undo!(append: true)                 # v3 (with same attributes as v1)
+```
+
+Note that `redo!` will not work after `undo!(append: true)` because the latter will create a new version
+instead of rolling back to an old one.
+Alternatively, you can configure Logidze to always default to `append: true`.
+
+```ruby
+Logidze.append_on_undo = true
+```
+
 
 ## Track responsibility (aka _whodunnit_)
 

data/lib/generators/logidze/install/templates/migration.rb.erb

@@ -19,17 +19,19 @@ class <%= @migration_class_name %> < ActiveRecord::Migration
     execute <<-SQL
       DROP FUNCTION IF EXISTS logidze_version(bigint, jsonb);
       DROP FUNCTION IF EXISTS logidze_snapshot(jsonb);
+      DROP FUNCTION IF EXISTS logidze_version(bigint, jsonb, text[]);
+      DROP FUNCTION IF EXISTS logidze_snapshot(jsonb, text[]);
     SQL
     <% end %>
 
     execute <<-SQL
-      CREATE OR REPLACE FUNCTION logidze_version(v bigint, data jsonb, blacklist text[] DEFAULT '{}') RETURNS jsonb AS $body$
+      CREATE OR REPLACE FUNCTION logidze_version(v bigint, data jsonb, ts timestamp with time zone, blacklist text[] DEFAULT '{}') RETURNS jsonb AS $body$
         DECLARE
           buf jsonb;
         BEGIN
           buf := jsonb_build_object(
                    'ts',
-                   (extract(epoch from now()) * 1000)::bigint,
+                   (extract(epoch from ts) * 1000)::bigint,
                    'v',
                     v,
                     'c',
@@ -43,12 +45,19 @@ class <%= @migration_class_name %> < ActiveRecord::Migration
       $body$
       LANGUAGE plpgsql;
 
-      CREATE OR REPLACE FUNCTION logidze_snapshot(item jsonb, blacklist text[] DEFAULT '{}') RETURNS jsonb AS $body$
+      CREATE OR REPLACE FUNCTION logidze_snapshot(item jsonb, ts_column text, blacklist text[] DEFAULT '{}') RETURNS jsonb AS $body$
+        DECLARE
+          ts timestamp with time zone;
         BEGIN
+          IF ts_column IS NULL THEN
+            ts := statement_timestamp();
+          ELSE
+            ts := coalesce((item->>ts_column)::timestamp with time zone, statement_timestamp());
+          END IF;
           return json_build_object(
             'v', 1,
             'h', jsonb_build_array(
-                   logidze_version(1, item, blacklist)
+                   logidze_version(1, item, ts, blacklist)
                  )
             );
         END;
@@ -62,7 +71,7 @@ class <%= @migration_class_name %> < ActiveRecord::Migration
         BEGIN
           res := obj;
           FOREACH key IN ARRAY keys
-          LOOP 
+          LOOP
             res := res - key;
           END LOOP;
           RETURN res;
@@ -93,7 +102,7 @@ class <%= @migration_class_name %> < ActiveRecord::Migration
             jsonb_set(
               log_data->'h',
               '{1}',
-              merged 
+              merged
             ) - 0
           );
         END;
@@ -111,23 +120,35 @@ class <%= @migration_class_name %> < ActiveRecord::Migration
           iterator integer;
           item record;
           columns_blacklist text[];
+          ts timestamp with time zone;
+          ts_column text;
         BEGIN
-          columns_blacklist := TG_ARGV[1];
+          ts_column := NULLIF(TG_ARGV[1], 'null');
+          columns_blacklist := TG_ARGV[2];
 
           IF TG_OP = 'INSERT' THEN
 
-            NEW.log_data := logidze_snapshot(to_jsonb(NEW.*), columns_blacklist);
-          
+            NEW.log_data := logidze_snapshot(to_jsonb(NEW.*), ts_column, columns_blacklist);
+
           ELSIF TG_OP = 'UPDATE' THEN
-          
+
             IF OLD.log_data is NULL OR OLD.log_data = '{}'::jsonb THEN
-              NEW.log_data := logidze_snapshot(to_jsonb(NEW.*), columns_blacklist);
+              NEW.log_data := logidze_snapshot(to_jsonb(NEW.*), ts_column, columns_blacklist);
               RETURN NEW;
             END IF;
 
             history_limit := NULLIF(TG_ARGV[0], 'null');
             current_version := (NEW.log_data->>'v')::int;
 
+            IF ts_column IS NULL THEN
+              ts := statement_timestamp();
+            ELSE
+              ts := (to_jsonb(NEW.*)->>ts_column)::timestamp with time zone;
+              IF ts IS NULL OR ts = (to_jsonb(OLD.*)->>ts_column)::timestamp with time zone THEN
+                ts := statement_timestamp();
+              END IF;
+            END IF;
+
             IF NEW = OLD THEN
               RETURN NEW;
             END IF;
@@ -158,7 +179,7 @@ class <%= @migration_class_name %> < ActiveRecord::Migration
             NEW.log_data := jsonb_set(
               NEW.log_data,
               ARRAY['h', size::text],
-              logidze_version(new_v, changes, columns_blacklist),
+              logidze_version(new_v, changes, ts, columns_blacklist),
               true
             );
 
@@ -183,9 +204,9 @@ class <%= @migration_class_name %> < ActiveRecord::Migration
   def down
     <% unless update? %>
     execute <<-SQL
-      DROP FUNCTION logidze_version(bigint, jsonb, text[]) CASCADE;
+      DROP FUNCTION logidze_version(bigint, jsonb, timestamp with time zone, text[]) CASCADE;
       DROP FUNCTION logidze_compact_history(jsonb) CASCADE;
-      DROP FUNCTION logidze_snapshot(jsonb, text[]) CASCADE;
+      DROP FUNCTION logidze_snapshot(jsonb, text, text[]) CASCADE;
       DROP FUNCTION logidze_logger() CASCADE;
     SQL
     <% end %>

data/lib/generators/logidze/model/model_generator.rb

@@ -1,3 +1,4 @@
+# rubocop:disable Metrics/BlockLength
 # frozen_string_literal: true
 require "rails/generators"
 require "rails/generators/active_record/migration/migration_generator"
@@ -20,6 +21,9 @@ module Logidze
       class_option :blacklist, type: :array, optional: true
       class_option :whitelist, type: :array, optional: true
 
+      class_option :timestamp_column, type: :string, optional: true,
+                                      desc: "Specify timestamp column"
+
       def generate_migration
         if options[:blacklist] && options[:whitelist]
           $stderr.puts "Use only one: --whitelist or --blacklist"
@@ -62,30 +66,46 @@ module Logidze
                     class_name.constantize.column_names - options[:whitelist]
                   end
 
-          array || []
+          format_pgsql_array(array)
+        end
+
+        def timestamp_column
+          value = options[:timestamp_column] || 'updated_at'
+          return if %w(nil null false).include?(value)
+          escape_pgsql_string(value)
         end
 
         def logidze_logger_parameters
-          if limit.nil? && columns_blacklist.empty?
-            ''
-          elsif !limit.nil? && columns_blacklist.empty?
-            limit
-          elsif !limit.nil? && !columns_blacklist.empty?
-            "#{limit}, #{format_pgsql_array(columns_blacklist)}"
-          elsif limit.nil? && !columns_blacklist.empty?
-            "null, #{format_pgsql_array(columns_blacklist)}"
-          end
+          format_pgsql_args(limit, timestamp_column, columns_blacklist)
         end
 
         def logidze_snapshot_parameters
-          return 'to_jsonb(t)' if columns_blacklist.empty?
-
-          "to_jsonb(t), #{format_pgsql_array(columns_blacklist)}"
+          format_pgsql_args('to_jsonb(t)', timestamp_column, columns_blacklist)
         end
 
         def format_pgsql_array(ruby_array)
+          return if ruby_array.blank?
           "'{" + ruby_array.join(', ') + "}'"
         end
+
+        def escape_pgsql_string(string)
+          return if string.blank?
+          "'#{string}'"
+        end
+
+        # Convenience method for formatting pg arguments.
+        # Some examples:
+        # format_pgsql_args('a', 'b', nil) #=> "a, b"
+        # format_pgsql_args(nil, '', 'c')  #=> "null, null, c"
+        # format_pgsql_args('a', '', [])   #=> "a"
+        def format_pgsql_args(*values)
+          args = []
+          values.reverse_each do |value|
+            formatted_value = value.presence || (args.any? && 'null')
+            args << formatted_value if formatted_value
+          end
+          args.compact.reverse.join(', ')
+        end
       end
 
       private

data/lib/generators/logidze/model/templates/migration.rb.erb

@@ -1,7 +1,7 @@
 class <%= @migration_class_name %> < ActiveRecord::Migration
   require 'logidze/migration'
   include Logidze::Migration
- 
+
   def up
     <% unless only_trigger? %>
     add_column :<%= table_name %>, :log_data, :jsonb

data/lib/logidze/model.rb

@@ -33,23 +33,38 @@ module Logidze
       def without_logging(&block)
         Logidze.without_logging(&block)
       end
+
+      def has_logidze?
+        true
+      end
     end
 
     # Use this to convert Ruby time to milliseconds
     TIME_FACTOR = 1_000
 
+    attr_accessor :logidze_requested_ts
+
     # Return a dirty copy of record at specified time
     # If time is less then the first version, then return nil.
     # If time is greater then the last version, then return self.
     def at(ts)
       ts = parse_time(ts)
+
       return nil unless log_data.exists_ts?(ts)
-      return self if log_data.current_ts?(ts)
+
+      if log_data.current_ts?(ts)
+        self.logidze_requested_ts = ts
+        return self
+      end
 
       version = log_data.find_by_time(ts).version
 
       object_at = dup
       object_at.apply_diff(version, log_data.changes_to(version: version))
+      object_at.id = id
+      object_at.logidze_requested_ts = ts
+
+      object_at
     end
 
     # Revert record to the version at specified time (without saving to DB)
@@ -93,10 +108,10 @@ module Logidze
 
     # Restore record to the previous version.
     # Return false if no previous version found, otherwise return updated record.
-    def undo!
+    def undo!(append: Logidze.append_on_undo)
       version = log_data.previous_version
       return false if version.nil?
-      switch_to!(version.version)
+      switch_to!(version.version, append: append)
     end
 
     # Restore record to the _future_ version (if `undo!` was applied)
@@ -109,9 +124,38 @@ module Logidze
 
     # Restore record to the specified version.
     # Return false if version is unknown.
-    def switch_to!(version)
-      return false unless at_version!(version)
-      self.class.without_logging { save! }
+    def switch_to!(version, append: Logidze.append_on_undo)
+      return false unless at_version(version)
+
+      if append && version < log_version
+        update!(log_data.changes_to(version: version))
+      else
+        at_version!(version)
+        self.class.without_logging { save! }
+      end
+    end
+
+    def association(name)
+      association = super
+
+      return association unless Logidze.associations_versioning
+
+      should_appply_logidze =
+        logidze_past? &&
+        association.klass.respond_to?(:has_logidze?) &&
+        !association.singleton_class.include?(Logidze::VersionedAssociation)
+
+      return association unless should_appply_logidze
+
+      association.singleton_class.prepend Logidze::VersionedAssociation
+
+      if association.is_a? ActiveRecord::Associations::CollectionAssociation
+        association.singleton_class.prepend(
+          Logidze::VersionedAssociation::CollectionAssociation
+        )
+      end
+
+      association
     end
 
     protected
@@ -122,6 +166,12 @@ module Logidze
       self
     end
 
+    def logidze_past?
+      return false unless @logidze_requested_ts
+
+      @logidze_requested_ts < Time.now.to_i * TIME_FACTOR
+    end
+
     def parse_time(ts)
       case ts
       when Numeric

data/lib/logidze/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Logidze
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/lib/logidze/versioned_association.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+module Logidze
+  module VersionedAssociation
+    def load_target
+      target = super
+
+      return target if inversed
+
+      time = owner.logidze_requested_ts
+
+      if target.is_a? Array
+        target.map! do |object|
+          object.at(time)
+        end.compact!
+      else
+        target.at!(time)
+      end
+
+      target
+    end
+
+    def stale_target?
+      logidze_stale? || super
+    end
+
+    def logidze_stale?
+      return false if !loaded? || inversed
+
+      unless target.is_a?(Array)
+        return owner.logidze_requested_ts != target.logidze_requested_ts
+      end
+
+      return false if target.empty?
+
+      target.any? do |object|
+        owner.logidze_requested_ts != object.logidze_requested_ts
+      end
+    end
+
+    module CollectionAssociation
+      def ids_reader
+        reload unless loaded?
+        super
+      end
+
+      def empty?
+        reload unless loaded?
+        super
+      end
+    end
+  end
+end

data/lib/logidze.rb

@@ -6,6 +6,7 @@ require "logidze/version"
 module Logidze
   require 'logidze/history'
   require 'logidze/model'
+  require 'logidze/versioned_association'
   require 'logidze/has_logidze'
   require 'logidze/responsible'
 
@@ -13,6 +14,16 @@ module Logidze
 
   require 'logidze/engine' if defined?(Rails)
 
+  class << self
+    # Determines if Logidze should append a version to the log after updating an old version.
+    attr_accessor :append_on_undo
+    attr_writer :associations_versioning
+
+    def associations_versioning
+      @associations_versioning || false
+    end
+  end
+
   # Temporary disable DB triggers.
   #
   # @example

data/logidze.gemspec

@@ -27,4 +27,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "simplecov", ">= 0.3.8"
   spec.add_development_dependency "ammeter", "~> 1.1.3"
   spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "timecop", "~> 0.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logidze
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - palkan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-06 00:00:00.000000000 Z
+date: 2017-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -136,6 +136,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  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'
 description: PostgreSQL JSON-based auditing
 email:
 - dementiev.vm@gmail.com
@@ -189,6 +203,7 @@ files:
 - lib/logidze/model.rb
 - lib/logidze/responsible.rb
 - lib/logidze/version.rb
+- lib/logidze/versioned_association.rb
 - logidze.gemspec
 homepage: http://github.com/palkan/logidze
 licenses: