logidze 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8df5f1ac5aa84c04a0874f222011418bb4ef0fb7
-  data.tar.gz: f354e24b771387fddfc094dd5ea902827d1f4deb
+  metadata.gz: 437f0707fbb215fbfb5655156b0f2f8450f2aa20
+  data.tar.gz: 533a010cbc9d240c5c70d565621ace20d571579a
 SHA512:
-  metadata.gz: 971a0acde6848091d4944632b579a37ab71335a9d7cab813aa43eae054fa4ae5359b8d654403d1ed8d7145c53afb87917366404a616f73fc71bb6af84536e0e4
-  data.tar.gz: 61d8ad229bb3d56bb5468b005e7e4907af9195bae3d187934a2acb7906b381628fd188ce99d2fb0af013bff8e22f750ae3c00f3fb7496725605b754ef9bad5bb
+  metadata.gz: 419c21e03ba9196ff236bb7d8ea1bc897eaa1e7b8573bff1e1196008113641975341712e2f55d0ea8abb887820c18e0f32b654ee673ea379ef263cdae63ce875
+  data.tar.gz: 8a885b62f97e4492001ef11a1961556faa0810d976f95fdb44dcb3071a5506622edc798f87aa6dd8fb27e40b46d605dd6adced7aa16e19278d2feb40f20beeb8

data/.hound.yml

@@ -0,0 +1,3 @@
+ruby:
+  enabled: true
+  config_file: .rubocop.yml

data/.travis.yml

@@ -29,9 +29,7 @@ before_script:
 
 matrix:
   include:
-    - rvm: 2.3.0
+    - rvm: 2.3.1
       gemfile: gemfiles/rails5.gemfile
-    - rvm: 2.3.0
+    - rvm: 2.3.1
       gemfile: gemfiles/rails42.gemfile
-  allow_failures:
-    - gemfile: gemfiles/rails5.gemfile

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# 0.2.1
+- Support both Rails 4 and 5
+
+# 0.2.0 (**Incompatible with 0.1.0**)
+
+- Rails 5 support

data/Gemfile

@@ -3,10 +3,10 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in logidze.gemspec
 gemspec
 
-local_gemfile = 'Gemfile.local'
+local_gemfile = "#{File.dirname(__FILE__)}/Gemfile.local"
 
 if File.exist?(local_gemfile)
   eval(File.read(local_gemfile)) # rubocop:disable Lint/Eval
 else
-  gem 'activerecord', '~>4.2'
+  gem 'activerecord', '~> 5.0.0'
 end

data/README.md

@@ -2,23 +2,24 @@
 
 # Logidze
 
-Logidze provides tools for logging DB records changes.
-**This is not [audited](https://github.com/collectiveidea/audited) or [paper_trail](https://github.com/airblade/paper_trail) alternative!**
+Logidze provides tools for logging DB records changes. Just like [audited](https://github.com/collectiveidea/audited) and [paper_trail](https://github.com/airblade/paper_trail) do (but [faster](bench/performance)).
 
-Logidze allows you to create DB-level log (using triggers) and gives you an API to browse this log.
-Log is stored with the record itself in JSONB column. No additional tables required.
+Logidze allows you to create a DB-level log (using triggers) and gives you an API to browse this log.
+The log is stored with the record itself in JSONB column. No additional tables required.
 Currently, only PostgreSQL 9.5+ is supported.
 
+[Read the story behind Logidze](https://evilmartians.com/chronicles/introducing-logidze?utm_source=logidze)
+
 Other requirements:
-- Ruby ~>2.3;
-- Rails ~>4.2;
+- Ruby ~> 2.3;
+- Rails >= 4.2 (Yes, Rails 5 is supported!).
 
 <a href="https://evilmartians.com/">
 <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
 
 ## Installation
 
-1. Add Logidze your application's Gemfile:
+1. Add Logidze to your application's Gemfile:
 
 ```ruby
 gem 'logidze'
@@ -48,7 +49,7 @@ rake db:migrate
 You can provide `limit` option to `generate` to limit the size of the log (by default it's unlimited):
 
 ```ruby
-rails generate logidze:mode Post --limit=10
+rails generate logidze:model Post --limit=10
 ```
 
 This also adds `has_logidze` line to your model, which adds methods for working with logs.
@@ -68,7 +69,7 @@ post.log_version #=> 3
 # Show log size (number of versions)
 post.log_size #=> 3
 
-# Get copy of a record at a given time 
+# Get copy of a record at a given time
 old_post = post.at(2.days.ago)
 
 # or revert the record itself to the previous state (without committing to DB)
@@ -134,12 +135,12 @@ The `log_data` column has the following format:
 ```js
 {
   "v": 2, // current record version,
-  "h": // list of changes 
+  "h": // list of changes
     [
       {
         "v": 1,  // change number
         "ts": 1460805759352, // change timestamp in milliseconds
-        "c": { 
+        "c": {
             "attr": "new value",  // updated fields with new values
             "attr2": "new value"
             }
@@ -148,7 +149,7 @@ The `log_data` column has the following format:
 }
 ```
 
-If you specified the limit in you trigger definition then log size would not exceed the specified size. When a new change occurs, and there is no more room for it, the two oldest changes get merged.
+If you specify the limit in the trigger definition then log size will not exceed the specified size. When a new change occurs, and there is no more room for it, the two oldest changes will be merged.
 
 ## Development
 
@@ -161,9 +162,9 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/palkan
 
 ## TODO
 
-- Exclude columns from log
-- Enhance `update_all` to support mass-logging
-- Other DB adapters
+- Exclude columns from the log.
+- Enhance update_all to support mass-logging.
+- Other DB adapters.
 
 ## License
 

data/bench/performance/README.md

@@ -0,0 +1,109 @@
+# Performance benchmarks: PaperTail vs. Logidze
+
+We want to compare Logidze with the most popular versioning library for Rails – PaperTrail.
+
+
+## Insert ([source](insert_bench.rb))
+
+```
+PaperTrail INSERT    213.148  (± 8.9%) i/s -      1.060k in   5.018504s
+   Logidze INSERT    613.387  (±16.3%) i/s -      2.970k in   5.036127s
+```
+
+
+## Update ([source](update_bench.rb))
+
+When changeset has 2 fields:
+
+```
+PaperTrail UPDATE #1    256.651  (±26.5%) i/s -      1.206k in   5.002300s
+   Logidze UPDATE #1    356.932  (±12.6%) i/s -      1.764k in   5.030560s
+```
+
+When changeset has 5 fields:
+
+```
+PaperTrail UPDATE #2    246.281  (±24.0%) i/s -      1.168k in   5.008234s
+   Logidze UPDATE #2    331.942  (±16.6%) i/s -      1.593k in   5.028135s
+```
+
+## Getting diff ([source](diff_bench.rb))
+
+PaperTrail doesn't have built-in method to calculate diff between not adjacent versions.
+We add `diff_from(ts)` and `diff_from_joined(ts)` (which uses SQL JOIN) methods to calculate diff from specified version using changesets.
+
+When each record has 10 versions:
+
+```
+       PT DIFF     20.874  (± 4.8%) i/s -    106.000  in   5.091402s
+PT (join) DIFF     20.619  (± 4.8%) i/s -    104.000  in   5.070160s
+  Logidze DIFF    109.482  (±24.7%) i/s -    500.000  in   5.103534s
+```
+
+When each record has 100 versions:
+
+```
+       PT DIFF      2.998  (± 0.0%) i/s -     15.000  in   5.019494s
+PT (join) DIFF      3.193  (± 0.0%) i/s -     16.000  in   5.030155s
+  Logidze DIFF     19.627  (±25.5%) i/s -     88.000  in   5.035555s
+```
+
+And, finally, when each record has 1000 versions:
+
+```
+       PT DIFF      0.270  (± 0.0%) i/s -     17.000  in  63.038374s
+PT (join) DIFF      0.235  (± 0.0%) i/s -     14.000  in  60.350886s
+  Logidze DIFF      2.022  (± 0.0%) i/s -    120.000  in  60.142965s
+```
+
+## Select memory usage ([source](memory_profile.rb))
+
+Logidze loads more data (because it stores log in-place). But how much more?
+We consider two cases for PaperTrail: when we want to calculate diff (and thus loading versions) and when we don't need any history related data.
+
+When each record has 10 versions:
+
+```
+PT records
+Total Allocated:                 27.8 KB
+Total Retained:                  16.59 KB
+Retained memory (per record):    2.14 KB
+
+PT with versions
+Total Allocated:                 228.01 KB
+Total Retained:                  170.78 KB
+Retained memory (per record):    143.13 KB
+
+Logidze records
+Total Allocated:                 46.45 KB
+Total Retained:                  34.73 KB
+Retained memory (per record):    4.11 KB
+```
+
+When each record has 100 versions:
+
+```
+PT with versions
+Total Allocated:                 1.92 MB
+Total Retained:                  1.56 MB
+Retained memory (per record):    1.53 MB
+
+Logidze records
+Total Allocated:                 162.48 KB
+Total Retained:                  150.76 KB
+Retained memory (per record):    15.4 KB
+```
+
+When each record has 1000 versions:
+
+```
+PT with versions
+Total Allocated:                 18.23 MB
+Total Retained:                  14.86 MB
+Retained memory (per record):    14.83 MB
+
+Logidze records
+Total Allocated:                 1.32 MB
+Total Retained:                  1.31 MB
+Retained memory (per record):    131.59 KB
+```

data/bench/performance/diff_bench.rb

@@ -0,0 +1,36 @@
+require 'benchmark/ips'
+require './setup'
+
+# How many records do you want?
+N = (ENV['N'] || '100').to_i
+
+# How many version each record has?
+V = (ENV['V'] || '10').to_i
+
+# Benchmark run time
+BM_TIME = (ENV['BM_TIME'] || 5).to_i
+
+BM_WARMUP = [(BM_TIME / 10), 2].max
+
+LogidzeBench.cleanup
+LogidzeBench.populate(N)
+
+ts1 = LogidzeBench.generate_versions(V/2)
+
+LogidzeBench.generate_versions(V/2)
+
+Benchmark.ips do |x|
+  x.config(time: BM_TIME, warmup: BM_WARMUP)
+
+  x.report('PT DIFF') do
+    User.random(N/2).diff_from(ts1)
+  end
+
+  x.report('PT (join) DIFF') do
+    User.random(N/2).diff_from_joined(ts1)
+  end
+
+  x.report('Logidze DIFF') do
+    LogidzeUser.random(N/2).diff_from(ts1)
+  end
+end

data/bench/performance/insert_bench.rb

@@ -0,0 +1,20 @@
+require 'benchmark/ips'
+require './setup'
+
+params = {
+  email: Faker::Internet.email,
+  position: Faker::Number.number(3),
+  name: Faker::Name.name,
+  age: Faker::Number.number(2),
+  bio: Faker::Lorem.paragraph
+}
+
+Benchmark.ips do |x|
+  x.report('PaperTrail INSERT') do
+    User.create!(params)
+  end
+
+  x.report('Logidze INSERT') do
+    LogidzeUser.create!(params)
+  end
+end

data/bench/performance/memory_profile.rb

@@ -0,0 +1,53 @@
+require './setup'
+require 'active_support/core_ext'
+require 'memory_profiler'
+
+# How many records do you want?
+N = (ENV['N'] || '10').to_i
+
+# How many version each record has?
+V = (ENV['V'] || '10').to_i
+
+LogidzeBench.cleanup
+LogidzeBench.populate(N)
+LogidzeBench.generate_versions(V)
+
+module MemoryReport
+  KILO_BYTE = 1024
+  MEGA_BYTE = 1024 * 1024
+
+  module_function
+  def call(msg, relation)
+    buffer = nil
+    delta = N / 10
+    r0 = MemoryProfiler.report do
+      buffer = relation.random(N - delta).to_a
+    end
+
+    buffer = nil
+    r1 = MemoryProfiler.report do
+      buffer = relation.to_a
+    end
+
+    $stdout.puts msg
+    $stdout.puts "Total Allocated:\t\t\t\t#{to_human_size(r1.total_allocated_memsize)}"
+    $stdout.puts "Total Retained:\t\t\t\t\t#{to_human_size(r1.total_retained_memsize)}"
+    $stdout.puts "Retained_memsize memory (per record):\t\t#{to_human_size((r1.total_retained_memsize - r0.total_retained_memsize) / delta)}"
+  end
+
+  module_function
+  def to_human_size(size)
+    if size > MEGA_BYTE
+      "#{(size.to_f / MEGA_BYTE).round(2)} MB"
+    elsif size > KILO_BYTE
+      "#{(size.to_f / KILO_BYTE).round(2)} KB"
+    else
+      "#{size} B"
+    end
+  end
+end
+
+
+MemoryReport.("PT records", User.all)
+MemoryReport.("PT with versions", User.joins(:versions).all)
+MemoryReport.("Logidze records", LogidzeUser.all)

data/bench/performance/setup.rb

@@ -0,0 +1,308 @@
+begin
+  require 'bundler/inline'
+rescue LoadError => e
+  $stderr.puts 'Bundler version 1.10 or later is required. Please update your Bundler'
+  raise e
+end
+
+gemfile(true) do
+  source 'https://rubygems.org'
+  gem 'activerecord', '~>4.2'
+  gem 'pg'
+  gem 'paper_trail', '~>4.2', require: false
+  gem 'pry-byebug'
+  gem 'faker'
+  gem 'benchmark-ips'
+  gem 'memory_profiler'
+end
+
+DB_NAME = ENV['DB_NAME'] || 'logidze_query_bench'
+
+begin
+  system("createdb #{DB_NAME}")
+rescue
+  $stdout.puts "DB already exists"
+end
+
+$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
+
+require 'active_record'
+require 'logger'
+require 'logidze'
+
+ActiveRecord::Base.send :include, Logidze::HasLogidze
+
+ActiveRecord::Base.establish_connection(adapter: 'postgresql', database: DB_NAME)
+
+at_exit do
+  ActiveRecord::Base.connection.disconnect!
+end
+
+require 'paper_trail'
+
+module LogidzeBench
+  module_function
+  def setup_db
+    ActiveRecord::Schema.define do
+      # PaperTrail setup
+      create_table :versions, force: true do |t|
+        t.string :item_type, null: false
+        t.integer :item_id, null: false
+        t.string :event, null: false
+        t.string :whodunnit
+        t.text :object
+        t.jsonb :object_changes
+
+        t.datetime :created_at
+      end
+
+      add_index :versions, [:item_type, :item_id]
+
+      # Logidze setup
+      enable_extension :hstore
+
+      execute <<~SQL
+        DO $$
+          BEGIN
+          EXECUTE 'ALTER DATABASE ' || current_database() || ' SET logidze.disabled TO off';
+          END;
+        $$
+        LANGUAGE plpgsql;
+      SQL
+
+      execute <<~SQL
+        CREATE OR REPLACE FUNCTION logidze_logger() RETURNS TRIGGER AS $body$
+          DECLARE
+            changes jsonb;
+            new_v integer;
+            ts bigint;
+            size integer;
+            history_limit integer;
+            current_version integer;
+            merged jsonb;
+            iterator integer;
+            item record;
+          BEGIN
+            ts := (extract(epoch from now()) * 1000)::bigint;
+
+            IF TG_OP = 'INSERT' THEN
+              changes := to_jsonb(NEW.*) - 'log_data';
+              new_v := 1;
+
+              NEW.log_data := json_build_object(
+                'v',
+                1,
+                'h',
+                jsonb_build_array(
+                  jsonb_build_object(
+                    'ts',
+                    ts,
+                    'v',
+                    new_v,
+                    'c',
+                    changes
+                  )
+                )
+              );
+            ELSIF TG_OP = 'UPDATE' THEN
+              history_limit := TG_ARGV[0];
+              current_version := (NEW.log_data->>'v')::int;
+
+              IF NEW = OLD THEN
+                RETURN NEW;
+              END IF;
+
+              IF current_version < (NEW.log_data#>>'{h,-1,v}')::int THEN
+                iterator := 0;
+                FOR item in SELECT * FROM jsonb_array_elements(NEW.log_data->'h')
+                LOOP
+                  IF (item.value->>'v')::int > current_version THEN
+                    NEW.log_data := jsonb_set(
+                      NEW.log_data,
+                      '{h}',
+                      (NEW.log_data->'h') - iterator
+                    );
+                  END IF;
+                  iterator := iterator + 1;
+                END LOOP;
+              END IF;
+
+              changes := hstore_to_jsonb_loose(
+                hstore(NEW.*) - hstore(OLD.*)
+              ) - 'log_data';
+
+              new_v := (NEW.log_data#>>'{h,-1,v}')::int + 1;
+
+              size := jsonb_array_length(NEW.log_data->'h');
+
+              NEW.log_data := jsonb_set(
+                NEW.log_data,
+                ARRAY['h', size::text],
+                jsonb_build_object(
+                  'ts',
+                  ts,
+                  'v',
+                  new_v,
+                  'c',
+                  changes
+                ),
+                true
+              );
+
+              NEW.log_data := jsonb_set(
+                NEW.log_data,
+                '{v}',
+                to_jsonb(new_v)
+              );
+
+              IF history_limit IS NOT NULL AND history_limit = size THEN
+                merged := jsonb_build_object(
+                  'ts',
+                  NEW.log_data#>'{h,1,ts}',
+                  'v',
+                  NEW.log_data#>'{h,1,v}',
+                  'c',
+                  (NEW.log_data#>'{h,0,c}') || (NEW.log_data#>'{h,1,c}')
+                );
+
+                NEW.log_data := jsonb_set(
+                  NEW.log_data,
+                  '{h}',
+                  jsonb_set(
+                    NEW.log_data->'h',
+                    '{1}',
+                    merged 
+                  ) - 0
+                );
+              END IF;
+            END IF;
+
+            return NEW;
+          END;
+          $body$
+          LANGUAGE plpgsql;
+      SQL
+
+      create_table :users, force: true do |t|
+        t.string :email
+        t.integer :position
+        t.string :name
+        t.text :bio
+        t.integer :age
+        t.timestamps
+      end
+
+      create_table :logidze_users, force: true do |t|
+        t.string :email
+        t.integer :position
+        t.string :name
+        t.text :bio
+        t.integer :age
+        t.jsonb :log_data, default: '{}', null: false
+        t.timestamps
+      end
+
+      execute <<~SQL
+        CREATE TRIGGER logidze_on_logidze_users
+        BEFORE UPDATE OR INSERT ON logidze_users FOR EACH ROW
+        WHEN (current_setting('logidze.disabled') <> 'on')
+        EXECUTE PROCEDURE logidze_logger();
+      SQL
+    end
+  end
+
+  module_function
+  def populate(n = 1_000)
+    n.times do
+      params = fake_params
+      User.create!(params)
+      LogidzeUser.create!(params)
+    end
+  end
+
+  module_function
+  def cleanup
+    LogidzeUser.delete_all
+    User.delete_all
+    PaperTrail::Version.delete_all
+  end
+
+  module_function
+  def generate_versions(num = 1)
+    num.times do 
+      User.find_each do |u|
+        u.update!(fake_params(sample: true))
+      end
+
+      LogidzeUser.find_each do |u|
+        u.update!(fake_params(sample: true))
+      end
+
+      # make at least 1 second between versions
+      sleep 1
+    end
+    Time.now
+  end
+
+  module_function
+  def fake_params(sample: false)
+    params = {
+      email: Faker::Internet.email,
+      position: Faker::Number.number(3),
+      name: Faker::Name.name,
+      age: Faker::Number.number(2),
+      bio: Faker::Lorem.paragraph
+    }
+
+    return params.slice(%i(email position name age bio).sample) if sample
+    params
+  end
+end
+
+module ARandom
+  def random(num = 1)
+    rel = order('random()')
+    num == 1 ? rel.first : rel.limit(num)
+  end
+end
+
+class User < ActiveRecord::Base
+  extend ARandom
+  has_paper_trail
+
+  def self.diff_from(ts)
+    includes(:versions).map { |u| { 'id' => u.id, 'changes' => u.diff_from(ts) } }
+  end
+
+  def self.diff_from_joined(ts)
+    eager_load(:versions).map { |u| { 'id' => u.id, 'changes' => u.diff_from(ts) } }
+  end
+
+  def diff_from(ts)
+    changes = {}
+    versions.each do |v|
+      next if v.created_at < ts
+      merge_changeset(changes, v.changeset)
+    end
+    changes
+  end
+
+  private
+
+  def merge_changeset(acc, data)
+    data.each do |k,v|
+      unless acc.key?(k)
+        acc[k] = { 'old' => v[0] }
+      end
+      acc[k]['new'] = v[1]
+    end
+  end
+end
+
+class LogidzeUser < ActiveRecord::Base
+  extend ARandom
+  has_logidze
+end
+
+# Run migration only if neccessary
+LogidzeBench.setup_db if ENV['FORCE'].present? || !ActiveRecord::Base.connection.tables.include?('logidze_users')

data/bench/performance/update_bench.rb

@@ -0,0 +1,36 @@
+require 'benchmark/ips'
+require './setup'
+
+params = {
+  age: Faker::Number.number(2),
+  email: Faker::Internet.email
+}
+
+params2 = {
+  email: Faker::Internet.email,
+  position: Faker::Number.number(3),
+  name: Faker::Name.name,
+  age: Faker::Number.number(2),
+  bio: Faker::Lorem.paragraph
+}
+
+LogidzeBench.cleanup
+LogidzeBench.populate
+
+Benchmark.ips do |x|
+  x.report('PT UPDATE #1') do
+    User.random.update!(params)
+  end
+
+  x.report('Logidze UPDATE #1') do
+    LogidzeUser.random.update!(params)
+  end
+
+  x.report('PT UPDATE #2') do
+    User.random.update!(params2)
+  end
+
+  x.report('Logidze UPDATE #2') do
+    LogidzeUser.random.update!(params2)
+  end
+end

data/bench/{Readme.md → triggers/Readme.md}

@@ -11,7 +11,7 @@ Create database:
 make setup
 ```
 
-You can provide database name through `DB` variable (by default "logidze_bench").
+You can provide database name by `DB` variable (defaults to "logidze_bench").
 
 Run all benchmarks:
 
@@ -32,7 +32,7 @@ make keys
 
 make keys2
 
-# raw update, no triggers
+# Raw update, no triggers
 make plain
 ```
 
@@ -44,15 +44,15 @@ make T=1000000
 
 # Results
 
-The benchmark shows that hstore and jsonb variants are of the same efficiency (running on MacPro 2013, 2.4 GHz Core i5, 4GB, SSD, 1 million transactions per test):
+The benchmark shows that hstore variant is the most efficient (running on MacPro 2013, 2.4 GHz Core i5, 4GB, SSD, 1 million transactions per test):
 
 |Mode    | TPS  | Statement latency (ms) |
 |--------|------|------------------------|
-| plain  | 3805 | 0.106                  |
-| hstore | 3061 | 0.165                  |
-| jsonb  | 3079 | 0.165                  |
-| jsonb2 | 3057 | 0.166                  |
-| keys   | 2606 | 0.209                  |
-| keys2  | 2610 | 0.216                  |
-
-_Logidze_ uses jsonb variant.
+| plain  | 3628 | 0.113                  |
+| hstore | 3015 | 0.168                  |
+| jsonb  | 1647 | 0.363                  |
+| jsonb2 | 1674 | 0.354                  |
+| keys   | 2355 | 0.219                  |
+| keys2  | 2542 | 0.210                  |
+
+_Logidze_ uses hstore variant.

data/circle.yml

@@ -3,13 +3,11 @@ machine:
     version: 2.3.0
 
   environment:
-    DATABASE_URL: postgres://postgres@127.0.0.1:5433/test_database
+    DATABASE_URL: postgres://postgres@127.0.0.1:5432/test_database
 
 dependencies:
   pre:
     - gem install bundler -v 1.11.2
-    - sudo service postgresql stop 9.4
-    - sudo cp -v /etc/postgresql/9.{4,5}/main/pg_hba.conf && sudo service postgresql restart 9.5
 
 database:
   override:

data/gemfiles/rails42.gemfile

@@ -1,5 +1,5 @@
 source 'https://rubygems.org'
 
-gem 'rails', "~>4.2"
+gem 'rails', '~> 4.2'
 
 gemspec path: '..'

data/gemfiles/rails5.gemfile

@@ -1,5 +1,6 @@
 source 'https://rubygems.org'
 
-gem 'rails', '5.0.0.rc1'
+gem 'rails', '~> 5.0.0'
+gem 'rspec-rails', '~> 3.5.0'
 
 gemspec path: '..'

data/lib/logidze/history.rb

@@ -1,38 +1,19 @@
 # frozen_string_literal: true
 module Logidze
-  # Log data coder used for attribute serialization
+  # Log data wrapper
   class History
+    require 'logidze/history/version'
+
     # History key
     HISTORY = 'h'
     # Version key
     VERSION = 'v'
 
-    # Represents one log item
-    class Version
-      # Timestamp key
-      TS = 'ts'
-      # Changes key
-      CHANGES = 'c'
-
-      attr_reader :data
-
-      def initialize(data)
-        @data = data
-      end
-
-      def version
-        data.fetch(VERSION)
-      end
-
-      def changes
-        data.fetch(CHANGES)
-      end
+    attr_reader :data
 
-      def time
-        data.fetch(TS)
-      end
-    end
+    delegate :size, to: :versions
 
+    ### Rails 4 ###
     def self.dump(object)
       ActiveSupport::JSON.encode(object)
     end
@@ -41,9 +22,7 @@ module Logidze
       new(json) unless json.nil?
     end
 
-    attr_reader :data
-
-    delegate :size, to: :versions
+    ### Rails 4 ###
 
     def initialize(data)
       @data = data

data/lib/logidze/history/type.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require 'active_model/type/value'
+
+module Logidze
+  class History
+    # Type for converting JSONB to and from History
+    class Type < ActiveModel::Type::Value
+      def type
+        :jsonb
+      end
+
+      # rubocop:disable Style/RescueModifier
+      def cast_value(value)
+        case value
+        when String
+          decoded = ::ActiveSupport::JSON.decode(value) rescue nil
+          History.new(decoded) if decoded.present?
+        when Hash
+          History.new(value)
+        when History
+          value
+        end
+      end
+      # rubocop:enable Style/RescueModifier
+
+      def serialize(value)
+        case value
+        when Hash, History
+          ::ActiveSupport::JSON.encode(value)
+        else
+          super
+        end
+      end
+
+      def changed_in_place?(raw_old_value, new_value)
+        cast_value(raw_old_value) != new_value
+      end
+    end
+  end
+end

data/lib/logidze/history/version.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Logidze
+  class History
+    # Represents one log item
+    class Version
+      # Timestamp key
+      TS = 'ts'
+      # Changes key
+      CHANGES = 'c'
+
+      attr_reader :data
+
+      def initialize(data)
+        @data = data
+      end
+
+      def version
+        data.fetch(VERSION)
+      end
+
+      def changes
+        data.fetch(CHANGES)
+      end
+
+      def time
+        data.fetch(TS)
+      end
+    end
+  end
+end

data/lib/logidze/model.rb

@@ -4,10 +4,16 @@ require 'active_support'
 module Logidze
   # Extends model with methods to browse history
   module Model
+    require 'logidze/history/type' if Rails::VERSION::MAJOR >= 5
+
     extend ActiveSupport::Concern
 
     included do
-      serialize :log_data, Logidze::History
+      if Rails::VERSION::MAJOR < 5
+        serialize :log_data, Logidze::History
+      else
+        attribute :log_data, Logidze::History::Type.new
+      end
 
       delegate :version, :size, to: :log_data, prefix: "log"
     end

data/lib/logidze/version.rb

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

data/logidze.gemspec

@@ -17,12 +17,11 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "rails", ">= 4.2.6"
+  spec.add_dependency "rails", ">= 4.2"
 
   spec.add_development_dependency "pg", "~>0.18"
   spec.add_development_dependency "bundler", "~> 1.11"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", ">= 3.4"
   spec.add_development_dependency "rspec-rails", ">= 3.4"
   spec.add_development_dependency "database_cleaner", "~> 1.5"
   spec.add_development_dependency "simplecov", ">= 0.3.8"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logidze
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - palkan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-12 00:00:00.000000000 Z
+date: 2016-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.6
+        version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.6
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -66,20 +66,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.4'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -158,6 +144,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".hound.yml"
 - ".rspec"
 - ".rubocop.yml"
 - ".travis.yml"
@@ -166,14 +153,20 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- bench/Makefile
-- bench/Readme.md
-- bench/bench.sql
-- bench/hstore_trigger_setup.sql
-- bench/jsonb_minus_2_setup.sql
-- bench/jsonb_minus_setup.sql
-- bench/keys2_trigger_setup.sql
-- bench/keys_trigger_setup.sql
+- bench/performance/README.md
+- bench/performance/diff_bench.rb
+- bench/performance/insert_bench.rb
+- bench/performance/memory_profile.rb
+- bench/performance/setup.rb
+- bench/performance/update_bench.rb
+- bench/triggers/Makefile
+- bench/triggers/Readme.md
+- bench/triggers/bench.sql
+- bench/triggers/hstore_trigger_setup.sql
+- bench/triggers/jsonb_minus_2_setup.sql
+- bench/triggers/jsonb_minus_setup.sql
+- bench/triggers/keys2_trigger_setup.sql
+- bench/triggers/keys_trigger_setup.sql
 - bin/console
 - bin/setup
 - circle.yml
@@ -190,6 +183,8 @@ files:
 - lib/logidze/engine.rb
 - lib/logidze/has_logidze.rb
 - lib/logidze/history.rb
+- lib/logidze/history/type.rb
+- lib/logidze/history/version.rb
 - lib/logidze/model.rb
 - lib/logidze/version.rb
 - logidze.gemspec