diffit 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 51a22c289600fbd9b443344c8d478ae2ab8c170b
+  data.tar.gz: 8b41bc0c64837641b34c3afeee1fb61fcf928a92
+SHA512:
+  metadata.gz: f348d9f2c135baf8f25cfec6b9331b07691a4e36b038393e1043aef05fb734ba0df718a433cbdc9d1c000e87dd1351170c353ffa4c002ef65061509e211edf11
+  data.tar.gz: 6d02351691c2fc6ef90bfa15567db530717b3d691935de86d3413006b35879890b02d8cbff0a69010e1ce16e08eb1363c4ff5264319ebd4edb17908ba0daeac1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Denis Lifanov
+
+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/Rakefile

@@ -0,0 +1,17 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Diffit'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks

data/lib/diffit.rb

@@ -0,0 +1,24 @@
+require 'diffit/version'
+
+module Diffit
+  extend ActiveSupport::Autoload
+
+  autoload :Changes
+  autoload :Record
+  autoload :Tracker
+  autoload :Trackable
+
+  mattr_accessor :function_name
+  @@function_name = :diffit_function
+
+  mattr_accessor :table_name
+  @@table_name = :diffit_column_diffs
+
+  mattr_accessor :strategy
+  @@strategy = :join
+
+  def self.configure
+    yield self
+  end
+
+end

data/lib/diffit/changes.rb

@@ -0,0 +1,98 @@
+module Diffit
+  class Changes
+
+    include Enumerable
+
+    attr_reader :timestamp
+    attr_reader :records
+
+    # Instantiates a Diffit::Changes with provided timestamp.
+    #
+    # @param timestamp [Time, DateTime, Date, Fixnum] date, time or timestamp.
+    # @return [Diffit::Changes] Diffit::Changes
+    def initialize(timestamp)
+      @timestamp = timestamp
+      @records = []
+    end
+
+    # Appends provided data to `self`.
+    #
+    # @param model [String] model name.
+    # @param data [Array(Hash)] data to append.
+    # @return [self] self
+    def append(model, data)
+      data.group_by { |row| row[:record_id] }.each do |record_id, changes|
+        @records << Record.new(model, record_id, changes.map { |c| c.slice(:column_name, :value, :changed_at)})
+      end
+      @length = nil
+      self
+    end
+
+    # Are there any changes?
+    #
+    # @return [Boolean] existence of changes.
+    def empty?
+      @records.empty?
+    end
+
+    # Number of changes.
+    #
+    # @return [Fixnum] number of changes
+    def length
+      @length ||= @records.inject(0) { |v,r| v += r.changes.length }
+    end
+
+    # Calls the given block once for each record in the collection.
+    #
+    # @return [Enumerator] if no block is given.
+    # @return [Array(Diffit::Record)] otherwise
+    def each
+      if block_given?
+        @records.each { |c| yield c }
+      else
+        @records.enum_for(:each)
+      end
+    end
+
+    # A short `String` representation of `self`.
+    #
+    # @return [String] the object converted to string.
+    def to_s
+      sprintf '#<%s:%#0x @timestamp: %s @changes: {%d}>',
+        self.class.to_s,
+        self.object_id,
+        @timestamp.strftime('%d/%b/%Y:%H:%M:%S %z'),
+        length
+    end
+
+    alias :to_str :to_s
+
+    # A `Hash` representation of `self`.
+    #
+    # @return [Hash] the object converted to hash.
+    def to_h
+      {timestamp: timestamp.to_i, changes: @records.map(&:to_h)}
+    end
+
+    alias :to_hash :to_h
+
+    # A JSON representation of `self`.
+    #
+    # @return [String] the object converted to JSON.
+    def to_json
+      to_h.to_json
+    end
+
+    def prepare!
+      @records.sort_by! { |record| record.last_changed_at }
+      @records.uniq! { |record| [record.model, record.record_id] }
+      nil
+    end
+
+    def cleanup!
+      @records.clear
+      @length = nil
+    end
+
+  end
+end

data/lib/diffit/record.rb

@@ -0,0 +1,27 @@
+module Diffit
+  class Record
+
+    attr_reader :model, :record_id, :changes
+
+    def initialize(model, record_id, changes)
+      @model     = model
+      @record_id = record_id
+      @changes   = changes
+    end
+
+    # Timestamp of the latest change.
+    #
+    # @return [Time] latest change timestamp.
+    def last_changed_at
+      @last_changed_at ||= @changes.map { |c| c[:changed_at] }.max
+    end
+
+    # A `Hash` representation of `self`.
+    #
+    # @return [Hash] the object converted to hash.
+    def to_h
+      {model: model, record_id: record_id, changes: changes}
+    end
+
+  end
+end

data/lib/diffit/trackable.rb

@@ -0,0 +1,21 @@
+module Diffit
+  module Trackable
+
+    def self.included(base)
+      base.extend(self)
+    end
+
+    def changes_since(timestamp)
+      Diffit::Tracker.new(timestamp).append(self)
+    end
+
+    alias :diff_from :changes_since
+
+    def changes_since_midnight
+      Diffit::Tracker.new(Time.now.beginning_of_day).append(self)
+    end
+
+    alias :diff_from_midnight :changes_since_midnight
+
+  end
+end

data/lib/diffit/tracker.rb

@@ -0,0 +1,205 @@
+module Diffit
+  class Tracker
+
+    attr_reader :timestamp
+
+    delegate :to_h, :to_hash, :to_json, :each, :length, :size, to: :changes
+
+    # Instantiates a Diffit::Tracker with provided timestamp.
+    #
+    # @param timestamp [Time, DateTime, Date, Fixnum] date, time or timestamp.
+    # @return [Diffit::Tracker] Diffit::Tracker
+    def initialize(timestamp)
+      if timestamp.respond_to?(:to_datetime)
+        @timestamp = timestamp.to_datetime
+      elsif timestamp.respond_to?(:to_i)
+        @timestamp = Time.at(timestamp.to_i).to_datetime
+      else
+        raise ArgumentError, "#{timestamp.inspect} is not a timestamp!"
+      end
+
+      @tracked = []
+      @changes = Diffit::Changes.new(self.timestamp)
+      @fetched = false
+    end
+
+    def initialize_clone(other)
+      @tracked = Array.new(@tracked)
+      @changes = Diffit::Changes.new(self.timestamp)
+    end
+
+    # Appends provided objects.
+    #
+    # @param object [ActiveRecord::Relation, ActiveRecord::Base, Array(ActiveRecord::Base), Array(ActiveRecord::Relation)]
+    # @return [Diffit::Tracker] new instance of Diffit::Tracker.
+    def append(*objects)
+      copy = self.clone
+      copy.append!(*objects)
+      copy
+    end
+
+    # Appends provided objects to `self`.
+    #
+    # @param object [ActiveRecord::Relation, ActiveRecord::Base, Array(ActiveRecord::Base), Array(ActiveRecord::Relation)]
+    # @return [self] self
+    def append!(*objects)
+      objects.flatten!
+      objects.each do |object|
+        if accepts?(object)
+          @tracked << object
+        else
+          raise ArgumentError, 'Expected ActiveRecord::Base or ActiveRecord::Relation'
+        end
+      end
+
+      @changes.cleanup!
+      @fetched = false
+      self
+    end
+
+    # Appends all changes.
+    #
+    # @return [Diffit::Tracker] a new instance of Diffit::Tracker.
+    def all
+      copy = self.clone
+      copy.all!
+      copy
+    end
+
+    # Appends all changes to `self`.
+    #
+    # @return [self] self.
+    def all!
+      @changes.cleanup!
+      handle_all.group_by { |row| row[:table_name] }.each do |t, records|
+        @changes.append t.classify, records
+      end
+      self
+    end
+
+    def changes
+      return @changes if @fetched
+
+      @tracked.each do |object|
+        if record?(object)
+          @changes.append object.model_name.name, handle_one(object)
+        elsif relation?(object)
+          model = object.respond_to?(:model) ? object.model : object.class
+          changes = case Diffit.strategy
+                    when :join     then handle_relation_with_join(object)
+                    when :subquery then handle_relation_with_subquery(object)
+                    end
+
+          @changes.append model.name, changes
+        end
+      end
+
+      @fetched = true
+      @changes.prepare!
+      @changes
+    end
+
+    private
+
+    def accepts?(object)
+      record?(object) || relation?(object)
+    end
+
+    def relation?(object)
+      object.is_a?(ActiveRecord::Relation) || ActiveRecord::Base.descendants.include?(object)
+    end
+
+    def record?(object)
+      object.is_a?(ActiveRecord::Base)
+    end
+
+    def handle_relation_with_subquery(relation)
+      table = Arel::Table.new(Diffit.table_name)
+
+      sanitized = relation.except(:select, :order, :group, :having, :includes).select(:id)
+
+      query = table.
+        where(table[:changed_at].gteq(self.timestamp)).
+        where(table[:table_name].eq(relation.table_name)).
+        order(:table_name, :record_id)
+
+      if sanitized.where_values.present? || sanitized.joins_values.present?
+        query = query.where(table[:record_id].in(Arel.sql(sanitized.to_sql)))
+      end
+
+      query = query.project(table[:record_id], table[:column_name], table[:value], table[:changed_at])
+
+      execute_query(query)
+    end
+
+    def handle_relation_with_join(relation)
+      table = Arel::Table.new(Diffit.table_name)
+
+      sanitized = relation.except(:select, :order, :group, :having, :includes)
+
+      query = sanitized.
+        from(table).
+        where(table[:changed_at].gteq(self.timestamp)).
+        where(table[:table_name].eq(relation.table_name)).
+        select(table[:record_id], table[:column_name], table[:value], table[:changed_at])
+
+      if sanitized.where_values.present? || sanitized.joins_values.present?
+
+        join_cond = Arel::Nodes::On.new(sanitized.arel_table[:id].eq(table[:record_id]))
+        join_arel = Arel::Nodes::InnerJoin.new(sanitized.arel_table, join_cond)
+
+        query = query.joins(join_arel)
+      end
+
+      execute_query(query)
+    end
+
+    def handle_one(record)
+      table = Arel::Table.new(Diffit.table_name)
+
+      query = table.
+        where(table[:changed_at].gteq(self.timestamp)).
+        where(table[:table_name].eq(record.class.table_name)).
+        where(table[:record_id].eq(record.id)).
+        order(:table_name, :record_id).
+        project(table[:record_id], table[:column_name], table[:value], table[:changed_at])
+
+      execute_query(query)
+    end
+
+    def handle_all
+      table = Arel::Table.new(Diffit.table_name)
+
+      query = table.
+        where(table[:changed_at].gteq(self.timestamp)).
+        order(:table_name, :record_id).
+        project(table[:table_name], table[:record_id], table[:column_name], table[:value], table[:changed_at])
+
+      execute_query(query)
+    end
+
+    # Executes raw SQL query.
+    # Uses ActiveRecord::Result, performs typecasting.
+    #
+    # @param query [ActiveRecord::Relation, Arel::SelectManager]
+    # @return [Array(Hash)] query result
+    def execute_query(query)
+      result  = ActiveRecord::Base.connection.select_all(query.to_sql)
+
+      cols = result.columns.map { |c| c.to_sym }
+      rows = result.cast_values
+
+      rows.map do |row|
+        hash, i, l = {}, 0, cols.length
+
+        while i < l
+          hash[cols[i]] = row[i]
+          i += 1
+        end
+
+        hash
+      end
+    end
+
+  end
+end

data/lib/diffit/version.rb

@@ -0,0 +1,3 @@
+module Diffit
+  VERSION = "0.0.1"
+end

data/lib/generators/diffit/base_generator.rb

@@ -0,0 +1,35 @@
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module Diffit
+  class BaseGenerator < Rails::Generators::Base
+
+    hide!
+
+    include Rails::Generators::Migration
+
+    def self.next_migration_number(dirname)
+      ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+
+    protected
+
+    def migration_exists?(basename)
+      self.class.migration_exists?('db/migrate', basename).present?
+    end
+
+    def create_diffit_migration(template, basename)
+      if migration_exists?(basename)
+        warning "Migration '#{basename}' already exists."
+      else
+        migration_template template, "db/migrate/#{basename}.rb"
+        sleep 1
+      end
+    end
+
+    def warning(message)
+      say_status '!', message, :red
+    end
+
+  end
+end

data/lib/generators/diffit/init/init_generator.rb

@@ -0,0 +1,32 @@
+require 'generators/diffit/base_generator'
+
+module Diffit
+  class InitGenerator < Diffit::BaseGenerator
+
+    source_root File.dirname(__FILE__)
+
+    desc 'Creates a diffit initializer and migrations for tracking table and stored procedure.'
+
+    argument :table_name, type: :string, required: true, desc: "Name of tracking table"
+
+    def prepare
+      Diffit.table_name = self.table_name
+      Diffit.function_name = "#{self.table_name}_function"
+    end
+
+    def create_initializer
+      template 'templates/diffit.erb', 'config/initializers/diffit.rb'
+    end
+
+    def create_table_migration
+      basename = "create_#{Diffit.table_name.to_s.underscore}"
+      create_diffit_migration 'migrations/create_table.erb', basename
+    end
+
+    def create_function_migration
+      basename = "create_#{Diffit.table_name.to_s.underscore}_function"
+      create_diffit_migration 'migrations/create_function.erb', basename
+    end
+
+  end
+end

data/lib/generators/diffit/init/migrations/create_function.erb

@@ -0,0 +1,102 @@
+class Create<%= Diffit.function_name.to_s.camelize %> < ActiveRecord::Migration
+  def up
+    execute <<-SQL
+      CREATE OR REPLACE FUNCTION <%= Diffit.function_name %>() RETURNS TRIGGER AS $$
+      DECLARE
+
+        n   JSON;       -- NEW as JSON
+        o   JSON;       -- OLD as JSON
+        t   TIMESTAMP;  -- current timestamp
+        a   RECORD;     -- attribute
+
+      BEGIN
+
+        t := current_timestamp;
+        n := row_to_json(NEW);
+
+        IF (TG_OP = 'UPDATE') THEN
+          o := row_to_json(OLD);
+        END IF;
+
+        -- select attributes (without pkeys)
+
+        FOR a IN SELECT
+          pga.attname AS name
+        FROM pg_attribute pga
+        LEFT JOIN pg_index pgi ON pgi.indrelid = pga.attrelid AND pga.attnum = ANY(pgi.indkey)
+        WHERE pga.attnum > 0 AND
+              pgi.indisprimary IS NOT true AND
+              pga.attrelid = TG_TABLE_NAME::regclass AND
+              NOT pga.attisdropped
+        ORDER BY pga.attnum
+        LOOP
+
+          IF (TG_OP = 'UPDATE' AND (n->(a.name))::text IS DISTINCT FROM (o->(a.name))::text) OR (TG_OP = 'INSERT') THEN
+
+            -- UPSERT
+
+            UPDATE <%= Diffit.table_name %>
+            SET
+              value       = n->(a.name),
+              changed_at  = t
+            WHERE
+              table_name  = TG_TABLE_NAME AND
+              record_id   = NEW.id AND
+              column_name = a.name;
+
+            IF NOT FOUND THEN
+
+              BEGIN
+
+                INSERT INTO <%= Diffit.table_name %>
+                  (table_name, record_id, column_name, value, changed_at)
+                VALUES
+                  (TG_TABLE_NAME, NEW.id, a.name, n->(a.name), t);
+
+              EXCEPTION
+              WHEN unique_violation THEN
+
+                -- handle unique violation (constraint: table_name, record_id, column_name)
+                -- TODO: notice
+                -- CHEKME
+
+                UPDATE <%= Diffit.table_name %>
+                SET
+                  value       = n->(a.name),
+                  changed_at  = t
+                WHERE
+                  table_name  = TG_TABLE_NAME AND
+                  record_id   = NEW.id AND
+                  column_name = a.name;
+
+              WHEN OTHERS THEN
+
+                -- TODO: notice
+
+                UPDATE <%= Diffit.table_name %>
+                SET
+                  value       = n->(a.name),
+                  changed_at  = t
+                WHERE
+                  table_name  = TG_TABLE_NAME AND
+                  record_id   = NEW.id AND
+                  column_name = a.name;
+
+              END;
+            END IF;
+          END IF;
+        END LOOP;
+
+        RETURN NEW;
+
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+  end
+
+  def down
+    execute <<-SQL
+      DROP FUNCTION IF EXISTS <%= Diffit.function_name %>();
+    SQL
+  end
+end

data/lib/generators/diffit/init/migrations/create_table.erb

@@ -0,0 +1,24 @@
+class Create<%= Diffit.table_name.to_s.camelize %> < ActiveRecord::Migration
+  def up
+    create_table :<%= Diffit.table_name %> do |t|
+      t.string :table_name
+      t.integer :record_id
+      t.string :column_name
+      t.json :value
+      t.timestamp :changed_at
+    end
+
+    add_index :<%= Diffit.table_name %>, :table_name
+    add_index :<%= Diffit.table_name %>, :record_id
+    add_index :<%= Diffit.table_name %>, :changed_at
+
+    execute <<-SQL
+      ALTER TABLE <%= Diffit.table_name %>
+      ADD CONSTRAINT record_identifiers UNIQUE (table_name, record_id, column_name);
+    SQL
+  end
+
+  def down
+    drop_table :<%= Diffit.table_name %>
+  end
+end

data/lib/generators/diffit/init/templates/diffit.erb

@@ -0,0 +1,12 @@
+Diffit.configure do |config|
+
+  # A name of the tracking table.
+  config.table_name = :<%= Diffit.table_name %>
+
+  # A name of the stored procedure.
+  config.function_name = :<%= Diffit.function_name %>
+
+  # A strategy to handle relations. Should be one of: [:join, :subquery].
+  config.strategy = :join
+
+end

data/lib/generators/diffit/triggers/migrations/create_triggers.erb

@@ -0,0 +1,32 @@
+class Create<%= Diffit.function_name.to_s.camelize %>TriggersOn<%= table_name.camelize %> < ActiveRecord::Migration
+  def up
+
+    execute <<-SQL
+      CREATE TRIGGER <%= Diffit.function_name %>_on_<%= table_name %>_insert_trigger
+      AFTER INSERT ON <%= table_name %>
+      FOR EACH ROW
+      EXECUTE PROCEDURE <%= Diffit.function_name %>();
+    SQL
+
+    execute <<-SQL
+      CREATE TRIGGER <%= Diffit.function_name %>_on_<%= table_name %>_update_trigger
+      AFTER UPDATE ON <%= table_name %>
+      FOR EACH ROW
+      WHEN (OLD.* IS DISTINCT FROM NEW.*)
+      EXECUTE PROCEDURE <%= Diffit.function_name %>();
+    SQL
+
+  end
+
+  def down
+
+    execute <<-SQL
+      DROP TRIGGER <%= Diffit.function_name %>_on_<%= table_name %>_insert_trigger ON <%= table_name %>;
+    SQL
+
+    execute <<-SQL
+      DROP TRIGGER <%= Diffit.function_name %>_on_<%= table_name %>_update_trigger ON <%= table_name %>;
+    SQL
+
+  end
+end

data/lib/generators/diffit/triggers/triggers_generator.rb

@@ -0,0 +1,33 @@
+require 'generators/diffit/base_generator'
+
+module Diffit
+  class TriggersGenerator < Diffit::BaseGenerator
+
+    source_root File.dirname(__FILE__)
+
+    argument :table_name, type: :string, required: true, desc: "ModelName or table_name"
+
+    desc 'Creates diffit triggers using a ModelName or a table_name provided.'
+
+    def create_triggers_migration
+      detect_table_name!
+      basename = "create_#{Diffit.function_name.to_s.underscore}_triggers_on_#{table_name}"
+      create_diffit_migration 'migrations/create_triggers.erb', basename
+    end
+
+    protected
+
+    def detect_table_name!
+      return if table_name == table_name.tableize
+
+      begin
+        klass = table_name.classify.constantize
+        self.table_name = klass.table_name if klass.respond_to?(:table_name)
+      rescue NameError
+      end
+
+      nil
+    end
+
+  end
+end

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification
+name: diffit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Denis Lifanov
+- Alexey Gaziev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: ammeter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: github-markup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Track changes in your tables using PostgreSQL triggers..
+email:
+- inadsence@gmail.com
+- alex.gaziev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- lib/diffit.rb
+- lib/diffit/changes.rb
+- lib/diffit/record.rb
+- lib/diffit/trackable.rb
+- lib/diffit/tracker.rb
+- lib/diffit/version.rb
+- lib/generators/diffit/base_generator.rb
+- lib/generators/diffit/init/init_generator.rb
+- lib/generators/diffit/init/migrations/create_function.erb
+- lib/generators/diffit/init/migrations/create_table.erb
+- lib/generators/diffit/init/templates/diffit.erb
+- lib/generators/diffit/triggers/migrations/create_triggers.erb
+- lib/generators/diffit/triggers/triggers_generator.rb
+homepage: https://github.com/gazay/diffit
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A simple solution to track changes in your tables.
+test_files: []