sequel_postgresql_triggers 1.0.3 → 1.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 125a5f23b1a05c7b989bd9bac3b9e4569f85af55
+  data.tar.gz: 24a4466e9bb4c91ec25238d56a3027e3091c684d
+SHA512:
+  metadata.gz: 7507b30166920a252b7c583828bb41e0a55531d9a58a9fcbea7e5aca24daad079b80d2e8fe2f9e65d146cf3c720f6b62ec6a2c373e494939ea4d3e9685a73cf4
+  data.tar.gz: 390410edef60b9930572664d41e94e1356b4959f205ad7389067bbf7d92f6dada7a89b1b475c403abdc228dc4b997c7ec8e2277994289fff64d5f4679ae8defa

data/README

@@ -51,6 +51,12 @@ This takes a table name and one or more column names, and adds
 an update trigger that raises an exception if you try to modify
 the value of any of the columns.
 
+=== Touch Propagation - pgt_touch
+
+This takes several arguments (again, see the RDoc) and sets up a
+trigger that watches one table for changes, and touches timestamps
+of related rows in a separate table.
+
 == License
 
 This library is released under the MIT License.  See the MIT-LICENSE

data/lib/sequel_postgresql_triggers.rb

@@ -110,6 +110,33 @@ module Sequel
         END;
         SQL
       end
+
+      # When rows in a table are updated, touches a timestamp of related rows
+      # in another table.
+      # Arguments:
+      # * main_table : name of table that is being watched for changes
+      # * touch_table : name of table that needs to be touched
+      # * column : name of timestamp column to be touched
+      # * expr : hash or array that represents the columns that define the relationship
+      # * opts : option hash, see module documentation
+      def pgt_touch(main_table, touch_table, column, expr, opts={})
+        trigger_name = opts[:trigger_name] || "pgt_t_#{main_table}__#{touch_table}"
+        function_name = opts[:function_name] || "pgt_t_#{main_table}__#{touch_table}"
+        cond = proc{|source| expr.map{|k,v| "#{quote_identifier(k)} = #{source}.#{quote_identifier(v)}"}.join(" AND ")}
+        sql = <<-SQL
+          BEGIN
+            IF (TG_OP = 'INSERT') THEN
+              UPDATE #{quote_schema_table(touch_table)} SET #{quote_identifier(column)} = CURRENT_TIMESTAMP WHERE #{cond['NEW']} AND #{quote_identifier(column)} <> CURRENT_TIMESTAMP;
+            ELSIF (TG_OP = 'UPDATE') THEN
+              UPDATE #{quote_schema_table(touch_table)} SET #{quote_identifier(column)} = CURRENT_TIMESTAMP WHERE #{cond['NEW']} AND #{quote_identifier(column)} <> CURRENT_TIMESTAMP;
+            ELSIF (TG_OP = 'DELETE') THEN
+              UPDATE #{quote_schema_table(touch_table)} SET #{quote_identifier(column)} = CURRENT_TIMESTAMP WHERE #{cond['OLD']} AND #{quote_identifier(column)} <> CURRENT_TIMESTAMP;
+            END IF;
+            RETURN NULL;
+          END;
+        SQL
+        pgt_trigger(main_table, trigger_name, function_name, [:insert, :delete, :update], sql, :after=>true)
+      end
       
       # Turns a column in the table into a updated at timestamp column, which
       # always contains the timestamp the record was inserted or last updated.
@@ -132,9 +159,9 @@ module Sequel
       
       # Add or replace a function that returns trigger to handle the action,
       # and add a trigger that calls the function.
-      def pgt_trigger(table, trigger_name, function_name, events, definition)
+      def pgt_trigger(table, trigger_name, function_name, events, definition, opts={})
         create_function(function_name, definition, :language=>:plpgsql, :returns=>:trigger, :replace=>true)
-        create_trigger(table, trigger_name, function_name, :events=>events, :each_row=>true)
+        create_trigger(table, trigger_name, function_name, :events=>events, :each_row=>true, :after=>opts[:after])
       end
     end
   end

data/spec/sequel_postgresql_triggers_spec.rb

@@ -7,161 +7,218 @@ DB = Sequel.connect(ENV['PGT_SPEC_DB']||'postgres:///spgt_test?user=postgres')
 $:.unshift(File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'lib'))
 require 'sequel_postgresql_triggers'
 
-context "PostgreSQL Triggers" do
-before do
-  DB.create_language(:plpgsql) if DB.server_version < 90000
-end
-after do
-  DB.drop_language(:plpgsql, :cascade=>true) if DB.server_version < 90000
-end
-
-context "PostgreSQL Counter Cache Trigger" do
+describe "PostgreSQL Triggers" do
   before do
-    DB.create_table(:accounts){integer :id; integer :num_entries, :default=>0}
-    DB.create_table(:entries){integer :id; integer :account_id}
-    DB.pgt_counter_cache(:accounts, :id, :num_entries, :entries, :account_id)
-    DB[:accounts] << {:id=>1}
-    DB[:accounts] << {:id=>2}
+    DB.create_language(:plpgsql) if DB.server_version < 90000
   end
-
-  after do
-    DB.drop_table(:entries, :accounts)
-  end
-
-  specify "Should modify counter cache when adding or removing records" do
-    DB[:accounts].filter(:id=>1).get(:num_entries).should == 0
-    DB[:accounts].filter(:id=>2).get(:num_entries).should == 0
-    DB[:entries] << {:id=>1, :account_id=>1}
-    DB[:accounts].filter(:id=>1).get(:num_entries).should == 1
-    DB[:accounts].filter(:id=>2).get(:num_entries).should == 0
-    DB[:entries] << {:id=>2, :account_id=>1}
-    DB[:accounts].filter(:id=>1).get(:num_entries).should == 2
-    DB[:accounts].filter(:id=>2).get(:num_entries).should == 0
-    DB[:entries] << {:id=>3, :account_id=>2}
-    DB[:accounts].filter(:id=>1).get(:num_entries).should == 2
-    DB[:accounts].filter(:id=>2).get(:num_entries).should == 1
-    DB[:entries].filter(:id=>2).delete
-    DB[:accounts].filter(:id=>1).get(:num_entries).should == 1
-    DB[:accounts].filter(:id=>2).get(:num_entries).should == 1
-    DB[:entries].delete
-    DB[:accounts].filter(:id=>1).get(:num_entries).should == 0
-    DB[:accounts].filter(:id=>2).get(:num_entries).should == 0
-  end
-end
-
-context "PostgreSQL Created At Trigger" do
-  before do
-    DB.create_table(:accounts){integer :id; timestamp :added_on}
-    DB.pgt_created_at(:accounts, :added_on)
-  end
-
   after do
-    DB.drop_table(:accounts)
+    DB.drop_language(:plpgsql, :cascade=>true) if DB.server_version < 90000
+  end
+
+  context "PostgreSQL Counter Cache Trigger" do
+    before do
+      DB.create_table(:accounts){integer :id; integer :num_entries, :default=>0}
+      DB.create_table(:entries){integer :id; integer :account_id}
+      DB.pgt_counter_cache(:accounts, :id, :num_entries, :entries, :account_id)
+      DB[:accounts] << {:id=>1}
+      DB[:accounts] << {:id=>2}
+    end
+
+    after do
+      DB.drop_table(:entries, :accounts)
+    end
+
+    specify "Should modify counter cache when adding or removing records" do
+      DB[:accounts].filter(:id=>1).get(:num_entries).should == 0
+      DB[:accounts].filter(:id=>2).get(:num_entries).should == 0
+      DB[:entries] << {:id=>1, :account_id=>1}
+      DB[:accounts].filter(:id=>1).get(:num_entries).should == 1
+      DB[:accounts].filter(:id=>2).get(:num_entries).should == 0
+      DB[:entries] << {:id=>2, :account_id=>1}
+      DB[:accounts].filter(:id=>1).get(:num_entries).should == 2
+      DB[:accounts].filter(:id=>2).get(:num_entries).should == 0
+      DB[:entries] << {:id=>3, :account_id=>2}
+      DB[:accounts].filter(:id=>1).get(:num_entries).should == 2
+      DB[:accounts].filter(:id=>2).get(:num_entries).should == 1
+      DB[:entries].filter(:id=>2).delete
+      DB[:accounts].filter(:id=>1).get(:num_entries).should == 1
+      DB[:accounts].filter(:id=>2).get(:num_entries).should == 1
+      DB[:entries].delete
+      DB[:accounts].filter(:id=>1).get(:num_entries).should == 0
+      DB[:accounts].filter(:id=>2).get(:num_entries).should == 0
+    end
+  end
+
+  context "PostgreSQL Created At Trigger" do
+    before do
+      DB.create_table(:accounts){integer :id; timestamp :added_on}
+      DB.pgt_created_at(:accounts, :added_on)
+    end
+
+    after do
+      DB.drop_table(:accounts)
+    end
+
+    specify "Should set the column upon insertion and ignore modifications afterward" do
+      DB[:accounts] << {:id=>1}
+      t = DB[:accounts].get(:added_on)
+      t.strftime('%F').should == Date.today.strftime('%F')
+      DB[:accounts].update(:added_on=>Date.today - 60)
+      DB[:accounts].get(:added_on).should == t
+      DB[:accounts] << {:id=>2}
+      ds = DB[:accounts].select(:added_on)
+      DB[:accounts].select((Sequel::SQL::NumericExpression.new(:NOOP, ds.filter(:id=>2)) > ds.filter(:id=>1)).as(:x)).first[:x].should == true
+      DB[:accounts].filter(:id=>1).update(:id=>3)
+      DB[:accounts].select((Sequel::SQL::NumericExpression.new(:NOOP, ds.filter(:id=>2)) > ds.filter(:id=>3)).as(:x)).first[:x].should == true
+    end
+  end
+
+  context "PostgreSQL Immutable Trigger" do
+    before do
+      DB.create_table(:accounts){integer :id; integer :balance, :default=>0}
+      DB.pgt_immutable(:accounts, :balance)
+      DB[:accounts] << {:id=>1}
+    end
+
+    after do
+      DB.drop_table(:accounts)
+    end
+
+    specify "Should allow modifying columns not marked as immutable" do
+      proc{DB[:accounts].update(:id=>2)}.should_not raise_error
+    end
+
+    specify "Should allow updating a column to its existing value" do
+      proc{DB[:accounts].update(:balance=>0)}.should_not raise_error
+      proc{DB[:accounts].update(:balance=>Sequel.*(:balance, :balance))}.should_not raise_error
+    end
+
+    specify "Should not allow modifying a column's value" do
+      proc{DB[:accounts].update(:balance=>1)}.should raise_error(Sequel::DatabaseError)
+    end
+
+    specify "Should handle NULL values correctly" do
+      proc{DB[:accounts].update(:balance=>nil)}.should raise_error(Sequel::DatabaseError)
+      DB[:accounts].delete
+      DB[:accounts] << {:id=>1, :balance=>nil}
+      proc{DB[:accounts].update(:balance=>nil)}.should_not raise_error
+      proc{DB[:accounts].update(:balance=>0)}.should raise_error(Sequel::DatabaseError)
+    end
+  end
+
+  context "PostgreSQL Sum Cache Trigger" do
+    before do
+      DB.create_table(:accounts){integer :id; integer :balance, :default=>0}
+      DB.create_table(:entries){integer :id; integer :account_id; integer :amount}
+      DB.pgt_sum_cache(:accounts, :id, :balance, :entries, :account_id, :amount)
+      DB[:accounts] << {:id=>1}
+      DB[:accounts] << {:id=>2}
+    end
+
+    after do
+      DB.drop_table(:entries, :accounts)
+    end
+
+    specify "Should modify sum cache when adding, updating, or removing records" do
+      DB[:accounts].filter(:id=>1).get(:balance).should == 0
+      DB[:accounts].filter(:id=>2).get(:balance).should == 0
+      DB[:entries] << {:id=>1, :account_id=>1, :amount=>100}
+      DB[:accounts].filter(:id=>1).get(:balance).should == 100
+      DB[:accounts].filter(:id=>2).get(:balance).should == 0
+      DB[:entries] << {:id=>2, :account_id=>1, :amount=>200}
+      DB[:accounts].filter(:id=>1).get(:balance).should == 300
+      DB[:accounts].filter(:id=>2).get(:balance).should == 0
+      DB[:entries] << {:id=>3, :account_id=>2, :amount=>500}
+      DB[:accounts].filter(:id=>1).get(:balance).should == 300
+      DB[:accounts].filter(:id=>2).get(:balance).should == 500
+      DB[:entries].exclude(:id=>2).update(:amount=>Sequel.*(:amount, 2))
+      DB[:accounts].filter(:id=>1).get(:balance).should == 400
+      DB[:accounts].filter(:id=>2).get(:balance).should == 1000
+      DB[:entries].filter(:id=>2).delete
+      DB[:accounts].filter(:id=>1).get(:balance).should == 200
+      DB[:accounts].filter(:id=>2).get(:balance).should == 1000
+      DB[:entries].delete
+      DB[:accounts].filter(:id=>1).get(:balance).should == 0
+      DB[:accounts].filter(:id=>2).get(:balance).should == 0
+    end
+  end
+
+  context "PostgreSQL Updated At Trigger" do
+    before do
+      DB.create_table(:accounts){integer :id; timestamp :changed_on}
+      DB.pgt_updated_at(:accounts, :changed_on)
+    end
+
+    after do
+      DB.drop_table(:accounts)
+    end
+
+    specify "Should set the column always to the current timestamp" do
+      DB[:accounts] << {:id=>1}
+      t = DB[:accounts].get(:changed_on)
+      t.strftime('%F').should == Date.today.strftime('%F')
+      DB[:accounts] << {:id=>2}
+      ds = DB[:accounts].select(:changed_on)
+      DB[:accounts].select((Sequel::SQL::NumericExpression.new(:NOOP, ds.filter(:id=>2)) > ds.filter(:id=>1)).as(:x)).first[:x].should == true
+      DB[:accounts].filter(:id=>1).update(:id=>3)
+      DB[:accounts].select((Sequel::SQL::NumericExpression.new(:NOOP, ds.filter(:id=>3)) > ds.filter(:id=>2)).as(:x)).first[:x].should == true
+    end
+  end
+
+  context "PostgreSQL Touch Trigger" do
+    before do
+      DB.create_table(:parents){integer :id1; integer :id2; integer :child_id; timestamp :changed_on}
+      DB.create_table(:children){integer :id; integer :parent_id1; integer :parent_id2; timestamp :changed_on}
+    end
+
+    after do
+      DB.drop_table(:children, :parents)
+    end
+
+    specify "Should update the timestamp column of the related table when adding, updating or removing records" do
+      DB.pgt_touch(:children, :parents, :changed_on, :id1=>:parent_id1)
+      DB[:parents] << {:id1=>1, :changed_on=>Date.today - 30}
+      DB[:children] << {:id=>1, :parent_id1=>1}
+      DB[:parents].get(:changed_on).strftime('%F').should == Date.today.strftime('%F')
+      DB[:parents].update(:changed_on=>Date.today - 30)
+      DB[:children].update(:id=>2)
+      DB[:parents].get(:changed_on).strftime('%F').should == Date.today.strftime('%F')
+      DB[:parents].update(:changed_on=>Date.today - 30)
+      DB[:children].delete
+      DB[:parents].get(:changed_on).strftime('%F').should == Date.today.strftime('%F')
+    end
+
+    specify "Should update the timestamp column of the related table when there is a composite foreign key" do
+      DB.pgt_touch(:children, :parents, :changed_on, :id1=>:parent_id1, :id2=>:parent_id2)
+      DB[:parents] << {:id1=>1, :id2=>2, :changed_on=>Date.today - 30}
+      DB[:children] << {:id=>1, :parent_id1=>1, :parent_id2=>2}
+      DB[:parents].get(:changed_on).strftime('%F').should == Date.today.strftime('%F')
+      DB[:parents].update(:changed_on=>Date.today - 30)
+      DB[:children].update(:id=>2)
+      DB[:parents].get(:changed_on).strftime('%F').should == Date.today.strftime('%F')
+      DB[:parents].update(:changed_on=>Date.today - 30)
+      DB[:children].delete
+      DB[:parents].get(:changed_on).strftime('%F').should == Date.today.strftime('%F')
+    end
+
+    specify "Should update timestamps correctly when two tables touch each other" do
+      DB.pgt_touch(:children, :parents, :changed_on, :id1=>:parent_id1)
+      DB.pgt_touch(:parents, :children, :changed_on, :id=>:child_id)
+      DB[:parents] << {:id1=>1, :child_id=>1, :changed_on=>Date.today - 30}
+      DB[:children] << {:id=>1, :parent_id1=>1, :changed_on=>Date.today - 30}
+      DB[:parents].get(:changed_on).strftime('%F').should == Date.today.strftime('%F')
+      DB[:children].get(:changed_on).strftime('%F').should == Date.today.strftime('%F')
+      time = DB[:parents].get(:changed_on)
+      DB[:parents].update(:id2=>4)
+      DB[:parents].get(:changed_on).should > time
+      DB[:children].get(:changed_on).should > time
+      time = DB[:parents].get(:changed_on)
+      DB[:children].update(:id=>1)
+      DB[:parents].get(:changed_on).should > time
+      DB[:children].get(:changed_on).should > time
+      time = DB[:parents].get(:changed_on)
+      DB[:children].delete
+      DB[:parents].get(:changed_on).should > time
+    end
   end
-
-  specify "Should set the column upon insertion and ignore modifications afterward" do
-    DB[:accounts] << {:id=>1}
-    t = DB[:accounts].get(:added_on)
-    t.strftime('%F').should == Date.today.strftime('%F')
-    DB[:accounts].update(:added_on=>Date.today - 60)
-    DB[:accounts].get(:added_on).should == t
-    DB[:accounts] << {:id=>2}
-    ds = DB[:accounts].select(:added_on)
-    DB[:accounts].select((Sequel::SQL::NumericExpression.new(:NOOP, ds.filter(:id=>2)) > ds.filter(:id=>1)).as(:x)).first[:x].should == true
-    DB[:accounts].filter(:id=>1).update(:id=>3)
-    DB[:accounts].select((Sequel::SQL::NumericExpression.new(:NOOP, ds.filter(:id=>2)) > ds.filter(:id=>3)).as(:x)).first[:x].should == true
-  end
-end
-
-context "PostgreSQL Immutable Trigger" do
-  before do
-    DB.create_table(:accounts){integer :id; integer :balance, :default=>0}
-    DB.pgt_immutable(:accounts, :balance)
-    DB[:accounts] << {:id=>1}
-  end
-
-  after do
-    DB.drop_table(:accounts)
-  end
-
-  specify "Should allow modifying columns not marked as immutable" do
-    proc{DB[:accounts].update(:id=>2)}.should_not raise_error
-  end
-
-  specify "Should allow updating a column to its existing value" do
-    proc{DB[:accounts].update(:balance=>0)}.should_not raise_error
-    proc{DB[:accounts].update(:balance=>:balance * :balance)}.should_not raise_error
-  end
-
-  specify "Should not allow modifying a column's value" do
-    proc{DB[:accounts].update(:balance=>1)}.should raise_error(Sequel::DatabaseError)
-  end
-
-  specify "Should handle NULL values correctly" do
-    proc{DB[:accounts].update(:balance=>nil)}.should raise_error(Sequel::DatabaseError)
-    DB[:accounts].delete
-    DB[:accounts] << {:id=>1, :balance=>nil}
-    proc{DB[:accounts].update(:balance=>nil)}.should_not raise_error
-    proc{DB[:accounts].update(:balance=>0)}.should raise_error(Sequel::DatabaseError)
-  end
-end
-
-context "PostgreSQL Sum Cache Trigger" do
-  before do
-    DB.create_table(:accounts){integer :id; integer :balance, :default=>0}
-    DB.create_table(:entries){integer :id; integer :account_id; integer :amount}
-    DB.pgt_sum_cache(:accounts, :id, :balance, :entries, :account_id, :amount)
-    DB[:accounts] << {:id=>1}
-    DB[:accounts] << {:id=>2}
-  end
-
-  after do
-    DB.drop_table(:entries, :accounts)
-  end
-
-  specify "Should modify sum cache when adding, updating, or removing records" do
-    DB[:accounts].filter(:id=>1).get(:balance).should == 0
-    DB[:accounts].filter(:id=>2).get(:balance).should == 0
-    DB[:entries] << {:id=>1, :account_id=>1, :amount=>100}
-    DB[:accounts].filter(:id=>1).get(:balance).should == 100
-    DB[:accounts].filter(:id=>2).get(:balance).should == 0
-    DB[:entries] << {:id=>2, :account_id=>1, :amount=>200}
-    DB[:accounts].filter(:id=>1).get(:balance).should == 300
-    DB[:accounts].filter(:id=>2).get(:balance).should == 0
-    DB[:entries] << {:id=>3, :account_id=>2, :amount=>500}
-    DB[:accounts].filter(:id=>1).get(:balance).should == 300
-    DB[:accounts].filter(:id=>2).get(:balance).should == 500
-    DB[:entries].exclude(:id=>2).update(:amount=>:amount * 2)
-    DB[:accounts].filter(:id=>1).get(:balance).should == 400
-    DB[:accounts].filter(:id=>2).get(:balance).should == 1000
-    DB[:entries].filter(:id=>2).delete
-    DB[:accounts].filter(:id=>1).get(:balance).should == 200
-    DB[:accounts].filter(:id=>2).get(:balance).should == 1000
-    DB[:entries].delete
-    DB[:accounts].filter(:id=>1).get(:balance).should == 0
-    DB[:accounts].filter(:id=>2).get(:balance).should == 0
-  end
-end
-
-context "PostgreSQL Updated At Trigger" do
-  before do
-    DB.create_table(:accounts){integer :id; timestamp :changed_on}
-    DB.pgt_updated_at(:accounts, :changed_on)
-  end
-
-  after do
-    DB.drop_table(:accounts)
-  end
-
-  specify "Should set the column always to the current timestamp" do
-    DB[:accounts] << {:id=>1}
-    t = DB[:accounts].get(:changed_on)
-    t.strftime('%F').should == Date.today.strftime('%F')
-    DB[:accounts] << {:id=>2}
-    ds = DB[:accounts].select(:changed_on)
-    DB[:accounts].select((Sequel::SQL::NumericExpression.new(:NOOP, ds.filter(:id=>2)) > ds.filter(:id=>1)).as(:x)).first[:x].should == true
-    DB[:accounts].filter(:id=>1).update(:id=>3)
-    DB[:accounts].select((Sequel::SQL::NumericExpression.new(:NOOP, ds.filter(:id=>3)) > ds.filter(:id=>2)).as(:x)).first[:x].should == true
-  end
-end
 end

metadata

@@ -1,76 +1,69 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: sequel_postgresql_triggers
-version: !ruby/object:Gem::Version 
-  hash: 17
-  prerelease: false
-  segments: 
-  - 1
-  - 0
-  - 3
-  version: 1.0.3
+version: !ruby/object:Gem::Version
+  version: 1.0.4
 platform: ruby
-authors: 
+authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-03-23 00:00:00 -07:00
-default_executable: 
-dependencies: []
-
+date: 2013-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: code@jeremyevans.net
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - README
 - MIT-LICENSE
 - lib/sequel_postgresql_triggers.rb
 - spec/sequel_postgresql_triggers_spec.rb
-has_rdoc: true
-homepage: 
-licenses: []
-
+homepage: https://github.com/jeremyevans/sequel_postgresql_triggers
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --inline-source
 - --line-numbers
 - --title
-- "Sequel PostgreSQL Triggers: Database enforced timestamps, immutable columns, and counter/sum caches"
+- 'Sequel PostgreSQL Triggers: Database enforced timestamps, immutable columns, and
+  counter/sum caches'
 - README
 - MIT-LICENSE
 - lib
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+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: 1.3.7
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Database enforced timestamps, immutable columns, and counter/sum caches
 test_files: []
-