padlock-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c3f4ce9e5ceed02e7eb545db3c689c66473e7656
+  data.tar.gz: 65c64cec2148b199a1422aa5333a5e226afb6dfc
+SHA512:
+  metadata.gz: e4d8e3d9c93c4dea62497344d7f733599bf0cc00b6e8c3b1404065150d3b8b06bbd20a3c3e8338ad0a869d21339ed0375bef8183d9eb4482bf7f8d64c3c21a14
+  data.tar.gz: 7ba8645376b082bb72ccb008eab2f3a733d9e5f53ce72cbafe1a769b073cb42773899aa2be6d4fb21bb798588021bc82fea031c931ab85e0f1e81430f87bf357

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,6 @@
+script: "bundle exec rspec spec"
+
+language: ruby
+
+rvm:
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in padlock.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 acuppy
+
+MIT License
+
+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/README.md

@@ -0,0 +1,129 @@
+# Padlock
+
+[![Build Status](https://travis-ci.org/CodingZeal/padlock.png?branch=master)](https://travis-ci.org/CodingZeal/padlock) [![Code Climate](https://codeclimate.com/github/CodingZeal/padlock.png)](https://codeclimate.com/github/CodingZeal/padlock)
+
+Lock a content item for editing.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'padlock'
+
+And then execute:
+
+    $ bundle
+
+Generate the padlocks table with the included Rails generator:
+
+```ruby
+$ rails generate padlock:install
+$ rake db:migrate
+```
+
+## Usage
+
+#### User:
+
+Padlock will associate every lock to a User object.  Therefore, you need
+to specify the User type model:
+
+```ruby
+class User < ActiveRecord::Base
+  acts_as_padlock_user
+end
+```
+
+Optionally set the foreign key:
+
+```ruby
+class User < ActiveRecord::Base
+  acts_as_padlock_user foreign_key: "admin_id"
+end
+```
+
+Once activated a User object can have many lockable objects
+
+#### Locking:
+
+All lockable objects are associated to a padlock user.
+
+```ruby
+current_user.padlock(lockable)  # => Lock the object for editing by the current_user. Override an existing lock
+current_user.padlock!(lockable) # => Lock the object and raise an exception if lockable is already locked by another user
+```
+
+You can also pass in multiple lockable objects to a single user.
+
+```ruby
+current_user.padlock(lockable_1 [, lockable_2, ...])
+```
+
+Or check the status of a single object.
+
+```ruby
+current_user.locked?(lockable) # => true/false
+```
+
+For integration with the Timeout gem, you can touch a lockable object and extend the padlock's TTL.
+
+```ruby
+currrent_user.touch(lockable_1 [, lockable, ...])
+```
+
+Padlocks can also be administered through the global Padlock object
+
+```ruby
+Padlock.lock(current_user, lockable [, lockable, ...]) # => locks it to the user
+Padlock.locked?(lockable)                              # => true/false
+Padlock.unlock!(lockable_1 [, lockable_2, ...])        # => unlocks a group of objects
+Padlock.unlocked?(lockable)                            # => true/false
+```
+
+#### Lockable Objects:
+
+Padlock assumes that all objects inherited from `ActiveRecord::Base` can be locked by a user record.
+
+```ruby
+lockable.locked?   # => true/false
+lockable.unlocked? # => true/false
+lockable.locked_by # => associated padlock user record
+lockable.lock_touched_at # => last time the padlock was updated
+lockable.unlock!   # => unsets the padlock
+```
+
+#### Stale Padlocks
+
+Lockables that have been locked for extended periods of time, may need to be reset.  In this case you can detect stale locks and unset them.
+
+```ruby
+Padlock.unlock_stale # => unlocks all padlocks that have not been touched in the last 24 hours
+```
+
+#### Configuration and Initialization
+
+You can customize certain configuration options by added an initializer (config/padlock.rb) or pre-boot configuration file:
+
+```ruby
+Padlock.config.timeout = 1.week         # => sets a new unlock stale timeout.  Default is 24 hours.
+Padlock.config.table_name = "..."       # => define the database table name for the padlocks.  Default is "padlocks"
+Padlock.config.user_foreign_key = "..." # => defines the foreign key relating to the User object.  Default is "user_id".
+Padlock.config.user_class_name = "..."  # => defines the user model class.  Default is "User".
+```
+
+## Credits
+
+Authored by Adam Cuppy (@acuppy) of Coding ZEAL (http://codingzeal.com)
+
+![Coding ZEAL](https://googledrive.com/host/0B3TWa6M1MsWeWmxRZWhscllwTzA/ZEAL-logo-final-150.png)
+
+This is freely distributed under the MIT license.  Use it, modify it,
+enjoy :)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/generators/padlock_generator.rb

@@ -0,0 +1,19 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Padlock
+  module Generators
+    class PadlockGenerator < ::Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.expand_path("../templates", __FILE__)
+
+      def self.next_migration_number(path)
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+
+      def copy_migration
+        migration_template 'migration.rb', "db/migrate/create_padlocks.rb"
+      end
+    end
+  end
+end

data/lib/generators/templates/migration.rb

@@ -0,0 +1,15 @@
+class CreatePadlocks < ActiveRecord::Migration
+  def up
+    create_table :padlocks do |t|
+      t.integer :lockable_id
+      t.string  :lockable_type
+      t.integer :user_id
+
+      t.timestamps
+    end
+  end
+
+  def down
+    drop_table :padlocks
+  end
+end

data/lib/padlock.rb

@@ -0,0 +1,65 @@
+require "ostruct"
+require "active_record"
+
+module Padlock
+  class << self
+    def config
+      @@config ||= OpenStruct.new(
+        table_name: "padlocks",
+        user_foreign_key: "user_id",
+        user_class_name: "User",
+        timeout: 1.day
+      )
+    end
+
+    def lock(user, *objects)
+      objects.each do |object|
+        unlock!(object)
+        user.padlocks.create(lockable: object)
+        object.reload
+      end
+    end
+
+    def locked? object
+      object.locked?
+    end
+
+    def unlock! *objects
+      objects.each { |object| object.unlock! }
+    end
+
+    def unlocked? object
+      object.unlocked?
+    end
+
+    def unlock_stale
+      stale_locks.destroy_all
+    end
+
+    def touch *objects
+      objects.each do |object|
+        if object.locked?
+          object.updated_at = Time.now
+          object.save
+        end
+      end
+    end
+
+    private
+
+    def timeout
+      Time.now - config.timeout
+    end
+
+    def stale_locks
+      Padlock::Instance.where("updated_at >= ?", timeout)
+    end
+  end
+end
+
+require "padlock/version"
+require "padlock/instance"
+require "padlock/lockable"
+require "padlock/user"
+require "padlock/integrations"
+require "generators/padlock_generator"

data/lib/padlock/instance.rb

@@ -0,0 +1,8 @@
+module Padlock
+  class Instance < ActiveRecord::Base
+    self.table_name = Padlock.config.table_name
+
+    belongs_to :lockable, polymorphic: true
+    belongs_to :user, class_name: "::#{Padlock.config.user_class_name}", foreign_key: Padlock.config.user_foreign_key
+  end
+end

data/lib/padlock/integrations.rb

@@ -0,0 +1 @@
+require File.expand_path("integrations/active_record", File.dirname(__FILE__))

data/lib/padlock/integrations/active_record.rb

@@ -0,0 +1,12 @@
+module Padlock
+  module ActiveRecord
+    def acts_as_padlock_user(opts={})
+      Padlock.config.user_class_name  = self.name
+      Padlock.config.user_foreign_key = opts[:foreign_key] if opts[:foreign_key].present?
+
+      class_eval { include Padlock::User }
+    end
+  end
+end
+
+ActiveRecord::Base.send :extend, Padlock::ActiveRecord

data/lib/padlock/lockable.rb

@@ -0,0 +1,33 @@
+module Padlock
+  module Lockable
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :padlock, class_name: "Padlock::Instance", as: :lockable
+    end
+
+    def locked?
+      self.padlock.present?
+    end
+
+    def unlocked?
+      !self.locked?
+    end
+
+    def locked_by
+      self.padlock.user if self.locked?
+    end
+
+    def locked_by? user
+      locked_by == user
+    end
+
+    def lock_touched_at
+      self.padlock.updated_at if self.locked?
+    end
+
+    def unlock!
+      self.padlock.destroy if self.locked?
+    end
+  end
+end

data/lib/padlock/user.rb

@@ -0,0 +1,27 @@
+module Padlock
+  module User
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :padlocks, class_name: "Padlock::Instance", foreign_key: Padlock.config.user_foreign_key
+    end
+
+    def padlock *objects
+      Padlock.lock(self, *objects)
+    end
+
+    def padlock! *objects
+      objects.each do |object|
+        if object.unlocked?
+          Padlock.lock(self, object)
+        else
+          raise "Attempting to lock an object that is already locked"
+        end
+      end
+    end
+
+    def locked? object
+      self.padlocks.include? object
+    end
+  end
+end

data/lib/padlock/version.rb

@@ -0,0 +1,3 @@
+module Padlock
+  VERSION = "0.1.0"
+end

data/padlock.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'padlock/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "padlock-rails"
+  spec.version       = Padlock::VERSION
+  spec.authors       = ["Coding Zeal", "Adam Cuppy"]
+  spec.email         = ["adam@codingzeal.com"]
+  spec.summary       = %q{Concurent editing collision prevention}
+  spec.homepage      = "https://github.com/CodingZeal/padlock"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", ">= 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", ">= 2.14.1"
+  spec.add_development_dependency "generator_spec"
+  spec.add_development_dependency "sqlite3", ">= 1.3.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "activerecord", "~> 4.0.0"
+end

data/spec/generators/padlock_generator_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe Padlock::Generators::PadlockGenerator, type: :generator do
+  destination File.expand_path("../../tmp", __FILE__)
+
+  before do
+    prepare_destination
+    run_generator
+  end
+
+  it "has generated the migration file" do
+    destination_root.should have_structure do
+      directory "db" do
+        directory "migrate" do
+          file "create_padlocks.rb" do
+            contains "class CreatePadlocks"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/padlock/instance_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Padlock::Instance do
+  let(:user)   { User.create!(name: "Jim Bob") }
+  let(:object) { User.create!(name: "Annie Bob") }
+
+  subject { Padlock::Instance.new(lockable: object, user: user) }
+
+  it { should be_a_kind_of ActiveRecord::Base }
+
+  its(:user) { should == user }
+  its(:lockable) { should == object }
+end

data/spec/padlock/lockable_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe LockableObject do
+  subject { LockableObject.create }
+
+  let(:user) { User.create!(name: "Jim Bob") }
+
+  context "when unlocked" do
+    it { should_not be_locked }
+    it { should be_unlocked }
+    it { expect(subject.locked_by).to be_nil }
+    it { expect(subject.lock_touched_at).to be_nil }
+  end
+
+  context "when locked" do
+    before { user.padlock(subject) }
+
+    it { should be_locked }
+    it { should_not be_unlocked }
+    it { expect(subject.locked_by).to eq user }
+    it { expect(subject.lock_touched_at).to_not be_nil }
+  end
+end

data/spec/padlock/padlock_spec.rb

@@ -0,0 +1,137 @@
+require "spec_helper"
+
+describe Padlock do
+  describe ".config" do
+    let(:config) { nil }
+
+    before { Padlock.class_variable_set(:@@config, config) }
+
+    it { expect( Padlock.config ).to be_a_kind_of OpenStruct }
+
+    it "returns a persistant object" do
+      expect( Padlock.config.random ).to be_nil
+      Padlock.config.random = "value"
+      expect( Padlock.config.random ).to eq "value"
+    end
+  end
+
+  describe ".lock" do
+    let(:object) { double(:object) }
+    let(:user) { double(:user) }
+    let(:padlocks) { double(:padlocks) }
+
+    before { user.stub(:padlocks).and_return(padlocks) }
+
+    it "unlocks the object before attempting to lock it" do
+      object.should_receive(:unlock!)
+      padlocks.stub(:create)
+      object.stub(:reload)
+      Padlock.lock(user, object)
+    end
+
+    it "creates the Padlock::Instance" do
+      object.stub(:unlock!)
+      padlocks.should_receive(:create).with(lockable: object)
+      object.stub(:reload)
+      Padlock.lock(user, object)
+    end
+
+    it "reloads the object" do
+      object.stub(:unlock!)
+      padlocks.stub(:create)
+      object.should_receive(:reload)
+      Padlock.lock(user, object)
+    end
+
+    it "accepts a splat of objects" do
+      expect(object).to receive(:unlock!).exactly(2).times
+      expect(padlocks).to receive(:create).exactly(2).times
+      expect(object).to receive(:reload).exactly(2).times
+      Padlock.lock(user, object, object)
+    end
+  end
+
+  describe ".locked?" do
+    let(:object) { User.create!(name: "Annie Bob") }
+
+    it do
+      object.should_receive(:locked?).and_return(true)
+      expect(Padlock.locked?(object)).to be_true
+    end
+  end
+
+  describe ".unlock!" do
+    let(:object)  { double(:object) }
+
+    context "single object" do
+      it do
+        object.should_receive(:unlock!).exactly(1).times
+        Padlock.unlock!(object)
+      end
+    end
+
+    context "multiple objects" do
+      it do
+        object.should_receive(:unlock!).exactly(2).times
+        Padlock.unlock!(object, object)
+      end
+    end
+  end
+
+  describe ".unlocked?" do
+    let(:object) { User.create!(name: "Annie Bob") }
+
+    it do
+      object.should_receive(:unlocked?).and_return(true)
+      expect(Padlock.unlocked?(object)).to be_true
+    end
+  end
+
+  describe ".unlock_stale" do
+    let(:object) { LockableObject.create!(created_at: Time.now - 1.week, updated_at: updated_at) }
+    let(:locked?) { true }
+    let(:updated_at) { Time.now - 2.hours }
+    let(:fake_relation) { double(:fake_relation) }
+
+    before do
+      Padlock::Instance.should_receive(:where).and_return(fake_relation)
+      fake_relation.should_receive(:destroy_all)
+      Padlock.unlock_stale
+    end
+
+    it "unlocks all lockables that have been locked more than 1 hour" do
+      expect(object).to be_unlocked
+    end
+  end
+
+  describe ".touch" do
+    let(:object) { LockableObject.create }
+    let(:locked?) { true }
+    let(:fake_padlock) { double(:fake_padlock) }
+
+    before do
+      object.stub(:locked?).and_return(locked?)
+      object.stub(:padlock).and_return(fake_padlock)
+    end
+
+    context "when locked" do
+      let(:locked?) { true }
+
+      it "sets a new value on the updated_at column and saves it" do
+        expect(object).to receive(:updated_at=)
+        expect(object).to receive(:save)
+        Padlock.touch(object)
+      end
+    end
+
+    context "when unlocked" do
+      let(:locked?) { false }
+
+      it "leaves the object uneffected" do
+        expect(object).to_not receive(:updated_at=)
+        expect(object).to_not receive(:save)
+        Padlock.touch(object)
+      end
+    end
+  end
+end

data/spec/padlock/user_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe User do
+  let(:object) { double(:object) }
+  subject { User.create!(name: "Jimmy John") }
+
+  describe "#padlock" do
+
+    it "delegates to Padlock.lock" do
+      Padlock.should_receive(:lock)
+      subject.padlock(object)
+    end
+
+    it "accepts multiple objects" do
+      Padlock.stub(:lock)
+      subject.padlock(object, object)
+    end
+  end
+
+  describe "#padlock!" do
+    context "when unlocked" do
+      before do
+        object.stub(:unlocked?).and_return(true)
+      end
+
+      context "with a single object" do
+        it "delegates to Padlock.lock" do
+          Padlock.should_receive(:lock).with(subject, object).exactly(1).times
+          subject.padlock!(object)
+        end
+      end
+
+      context "with multiple objects" do
+        it "delegates to Padlock.lock for each object" do
+          Padlock.should_receive(:lock).with(subject, object).exactly(2).times
+          subject.padlock!(object, object)
+        end
+      end
+    end
+  end
+
+  describe "#locked?" do
+    before { subject.stub_chain(:padlocks, :include?).and_return(include?) }
+
+    context "when included" do
+      let(:include?) { true }
+      it { expect(subject.locked?(object)).to be_true }
+    end
+
+    context "when not included" do
+      let(:include?) { false }
+      it { expect(subject.locked?(object)).to be_false }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'active_record'
+require 'rspec'
+require 'rspec/autorun'
+require 'pry'
+require "generator_spec"
+
+PROJECT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..')).freeze
+$LOAD_PATH << File.join(PROJECT_ROOT, 'lib')
+Dir[File.join(PROJECT_ROOT, 'spec/support/**/*.rb')].each { |file| require(file) }
+
+require 'padlock'
+
+RSpec.configure do |c|
+  c.before(:all) { setup_db }
+  c.after(:all)  { teardown_db }
+end
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+def setup_db
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :users do |t|
+      t.string   :name
+      t.timestamps
+    end
+
+    create_table :lockable_objects do |t|
+      t.timestamps
+    end
+
+    create_table :padlocks do |t|
+      t.integer :lockable_id
+      t.string  :lockable_type
+      t.integer :user_id
+      t.timestamps
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+class User < ActiveRecord::Base
+  acts_as_padlock_user
+end
+
+class LockableObject < ActiveRecord::Base
+  include Padlock::Lockable
+end

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: padlock-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Coding Zeal
+- Adam Cuppy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: generator_spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+description: 
+email:
+- adam@codingzeal.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/generators/padlock_generator.rb
+- lib/generators/templates/migration.rb
+- lib/padlock.rb
+- lib/padlock/instance.rb
+- lib/padlock/integrations.rb
+- lib/padlock/integrations/active_record.rb
+- lib/padlock/lockable.rb
+- lib/padlock/user.rb
+- lib/padlock/version.rb
+- padlock.gemspec
+- spec/generators/padlock_generator_spec.rb
+- spec/padlock/instance_spec.rb
+- spec/padlock/lockable_spec.rb
+- spec/padlock/padlock_spec.rb
+- spec/padlock/user_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/CodingZeal/padlock
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Concurent editing collision prevention
+test_files:
+- spec/generators/padlock_generator_spec.rb
+- spec/padlock/instance_spec.rb
+- spec/padlock/lockable_spec.rb
+- spec/padlock/padlock_spec.rb
+- spec/padlock/user_spec.rb
+- spec/spec_helper.rb