unique_attributes 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 70a00c890458b0211c83d2c03761dc25076d3eca
+  data.tar.gz: fe8105fe343e4eb9b88fe05b49e9d64cdf77526a
+SHA512:
+  metadata.gz: f7ac7936da0e54159abd1ef4e92240b2cdbf449cbe960eb45b830e037e1798c64a14f287020958f78721991e68321bbe02198abb4fa8f054e3d1dae2ae91238a
+  data.tar.gz: 576ebc540a990b71865ecbbd9bc919802308efe216ae7f910c171b0f4c5f1b19fbebaf32042e10b87c1e028dfd214ae8f31311bc9d351506bbe66485eba302af

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.gem

data/.overcommit.yml

@@ -0,0 +1,7 @@
+PreCommit:
+  Brakeman:
+    enabled: false # Disable Brakeman since this isn't a Rails app.
+  RailsSchemaUpToDate:
+    enabled: false
+  Reek:
+    enabled: false

data/.rubocop.yml

@@ -0,0 +1,265 @@
+# This (http://c2.com/cgi/wiki?AbcMetric) is super obnoxious
+AbcSize:
+  Enabled: false
+
+AccessorMethodName:
+  Enabled: false
+
+Alias:
+  Enabled: false
+
+AllCops:
+  Exclude:
+    - "vendor/**/*"
+    - "spec/dummy/**/*"
+    - "db/schema.rb"
+    - "db/migrate/**/*"
+  RunRailsCops: true
+
+AmbiguousOperator:
+  Enabled: false
+
+AmbiguousRegexpLiteral:
+  Enabled: false
+
+ArrayJoin:
+  Enabled: false
+
+AsciiComments:
+  Enabled: false
+
+AsciiIdentifiers:
+  Enabled: false
+
+AssignmentInCondition:
+  Enabled: true
+
+Attr:
+  Enabled: false
+
+BlockNesting:
+  Enabled: false
+
+BracesAroundHashParameters:
+  Enabled: false
+
+CaseEquality:
+  Enabled: false
+
+CharacterLiteral:
+  Enabled: false
+
+ClassLength:
+  Enabled: false
+
+ClassVars:
+  Enabled: false
+
+CollectionMethods:
+  PreferredMethods:
+    find: detect
+    reduce: inject
+    collect: map
+    find_all: select
+
+ColonMethodCall:
+  Enabled: false
+
+CommentAnnotation:
+  Enabled: false
+
+ConditionPosition:
+  Enabled: false
+
+CyclomaticComplexity:
+  Enabled: false
+
+Delegate:
+  Enabled: false
+
+DeprecatedClassMethods:
+  Enabled: false
+
+DeprecatedHashMethods:
+  Enabled: false
+
+Documentation:
+  Enabled: false
+
+DotPosition:
+  EnforcedStyle: trailing
+
+DoubleNegation:
+  Enabled: false
+
+ElseLayout:
+  Enabled: false
+
+EmptyLiteral:
+  Enabled: false
+
+Encoding:
+  Enabled: false
+
+EvenOdd:
+  Enabled: false
+
+FileName:
+  Enabled: false
+
+FlipFlop:
+  Enabled: false
+
+FormatString:
+  Enabled: false
+
+GlobalVars:
+  Enabled: false
+
+GuardClause:
+  Enabled: false
+
+HandleExceptions:
+  Enabled: false
+
+IfUnlessModifier:
+  Enabled: false
+
+IfWithSemicolon:
+  Enabled: false
+
+InvalidCharacterLiteral:
+  Enabled: false
+
+Lambda:
+  Enabled: false
+
+LambdaCall:
+  Enabled: false
+
+LineEndConcatenation:
+  Enabled: false
+
+LineLength:
+  Max: 80
+
+LiteralInCondition:
+  Enabled: false
+
+LiteralInInterpolation:
+  Enabled: false
+
+Loop:
+  Enabled: false
+
+MethodLength:
+  Enabled: false
+
+ModuleFunction:
+  Enabled: false
+
+NegatedIf:
+  Enabled: false
+
+NegatedWhile:
+  Enabled: false
+
+Next:
+  Enabled: false
+
+NilComparison:
+  Enabled: false
+
+Not:
+  Enabled: false
+
+NumericLiterals:
+  Enabled: false
+
+OneLineConditional:
+  Enabled: false
+
+OpMethod:
+  Enabled: false
+
+ParameterLists:
+  Enabled: false
+
+ParenthesesAsGroupedExpression:
+  Enabled: false
+
+PercentLiteralDelimiters:
+  PreferredDelimiters:
+    '%': '{}'
+
+PerceivedComplexity:
+  Enabled: false
+
+PerlBackrefs:
+  Enabled: false
+
+PredicateName:
+  Enabled: false
+
+Proc:
+  Enabled: false
+
+RaiseArgs:
+  Enabled: false
+
+RedundantReturn:
+  AllowMultipleReturnValues: true
+
+RegexpLiteral:
+  Enabled: false
+
+RequireParentheses:
+  Enabled: false
+
+SelfAssignment:
+  Enabled: false
+
+SignalException:
+  EnforcedStyle: only_raise
+
+SingleLineBlockParams:
+  Enabled: false
+
+SingleLineMethods:
+  Enabled: false
+
+SpecialGlobalVars:
+  Enabled: false
+
+StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/MultilineBlockChain:
+  Enabled: false
+
+VariableInterpolation:
+  Enabled: false
+
+TrailingComma:
+  Enabled: false
+
+TrivialAccessors:
+  Enabled: false
+
+UnderscorePrefixedVariableName:
+  Enabled: false
+
+VariableInterpolation:
+  Enabled: false
+
+Void:
+  Enabled: false
+
+WhenThen:
+  Enabled: false
+
+WhileUntilModifier:
+  Enabled: false
+
+WordArray:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+rvm:
+- 2.0.0
+- 2.1.4
+before_script:
+  - psql -c 'create database unique_attributes_test;' -U postgres
+script: bundle exec rspec
+addons:
+  postgresql: "9.3"
+  code_climate:
+    repo_token: 77d19511a3073b3dcadd6b4abbc87e5dd46c3db1ba6815a32545e91d9996d820
+notifications:
+  email: false
+  hipchat:
+    rooms:
+      secure: Q3zxZGqtrcbhw3S038A1LSmWks5uEKxKUjGee5q30PWCkoNEg9VxgbcMH2ZzMA10BCvHcKMI4yUk7yy/WyO8UKYprFA8707M7FjBmxfY62GK9K58sPBDUrnpCAfxGqyZZ1oXofSJamNPHh3G8U18yZhWt4j/5XHrwzBo8+p/0bI=

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Panorama Education
+
+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,113 @@
+[![Code Climate](https://codeclimate.com/github/panorama-ed/unique_attributes/badges/gpa.svg)](https://codeclimate.com/github/panorama-ed/unique_attributes) [![Test Coverage](https://codeclimate.com/github/panorama-ed/unique_attributes/badges/coverage.svg)](https://codeclimate.com/github/panorama-ed/unique_attributes) [![Inline docs](http://inch-ci.org/github/panorama-ed/unique_attributes.png)](http://inch-ci.org/github/panorama-ed/unique_attributes) [![Build Status](https://travis-ci.org/panorama-ed/unique_attributes.svg)](https://travis-ci.org/panorama-ed/unique_attributes)
+
+# UniqueAttributes
+
+UniqueAttributes gives you an easy way to ensure that autogenerated fields on
+your ActiveRecord models are unique.
+
+Auto-assign usernames for your users? You've come to the right place.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'unique_attributes'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install unique_attributes
+
+## Usage
+
+```ruby
+require "unique_attributes"
+
+class User < ActiveRecord::Base
+  include UniqueAttributes
+
+  unique_attribute :username, proc { SecureRandom.hex }
+end
+```
+
+Voilà! Now let's see how it works:
+
+```ruby
+> user = User.new
+> user.username
+=> nil
+> user.save!
+> user.username
+=> "1a4523822c1a2bebdfc0c036c94f1e0e"
+```
+
+Your user now has a username that's automatically set via the proc you specify,
+and it's guaranteed to be unique among all users.
+
+You can still change the value at any time:
+```ruby
+> user.username = "Grace Hopper"
+> user.save!
+> user.username
+=> "Grace Hopper"
+```
+
+What if the uniqueness is scoped by something? No problem:
+```ruby
+unique_attribute :username, proc { SecureRandom.hex }, scope: :group_id
+```
+
+You can pass in any scopes you could pass into a Rails uniqueness validation.
+Now:
+```ruby
+> user1 = User.new(group_id: 1)
+> user2 = User.new(group_id: 1)
+> user3 = User.new(group_id: 2)
+```
+
+Because `user1` and `user2` are in the same uniqueness scope, we are guaranteed
+to give them different usernames. `user3` could have the same username as either
+of them since it's outside the uniqueness scope.
+
+-----
+
+**Note that UniqueAttributes assumes you have an accompanying unique
+index in your database:**
+```ruby
+add_index :users, :username, unique: true
+```
+
+or, in the case of a scoped uniqueness:
+```ruby
+add_index :users, [:username, :group_id], unique: true
+```
+
+## Database Compatibility
+
+UniqueAttributes currently supports **PostgreSQL** and **SQLite3**, though
+adding support for your favorite database adapter is as easy as writing a regex
+to parse its uniqueness violation error messages. (Note that MySQL's messages do
+not give granular enough output and thus are not supported currently. Maybe you
+can come up with a fix?)
+
+## Contributing
+
+1. Fork it (https://github.com/panorama-ed/unique_attributes/fork)
+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 a new Pull Request
+
+**Make sure your changes have appropriate tests (`bundle exec rspec`)
+and conform to the Rubocop style specified.** We use
+[overcommit](https://github.com/causes/overcommit) to enforce good code.
+
+## License
+
+UniqueAttributes is released under the
+[MIT License](https://github.com/panorama-ed/unique_attributes/blob/master/LICENSE.txt).

data/Rakefile

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

data/lib/unique_attributes.rb

@@ -0,0 +1,106 @@
+require "unique_attributes/version"
+
+require "active_support/concern"
+
+# UniqueAttributes provides the unique_attribute method to assign a unique
+# attribute to the given model, using the passed block.
+
+# Example: unique_attribute :code { SecureRandom.random_number(1000) }
+
+module UniqueAttributes
+  extend ActiveSupport::Concern
+
+  # If we try saving an object 50 times and it fails each time, raise an error.
+  # This should be high enough to handle even fairly collision-prone attribute
+  # generation algorithms.
+  SAVE_ATTEMPTS_LIMIT = 50
+
+  included do
+    class_attribute :unique_attributes
+    self.unique_attributes = Hash.new
+
+    # Indicate that a given attribute is unique and should be auto-assigned with
+    # the given block.
+    # @param name [Symbol] the name of the ActiveRecord attribute
+    # @param block [Proc] the code to use to auto-assign the attribute
+    # @param scope the scope to limit uniqueness by for the attribute; uses the
+    #   same format as Rails' `validates *, uniqueness: { scope: __ }` pattern.
+    def self.unique_attribute(name, block, scope: nil)
+      unique_attributes[name] = block # Store the proc for this attribute.
+
+      # Use a uniqueness scope if one is passed; otherwise have global
+      # uniqueness.
+      uniqueness_options = scope ? { scope: scope } : true
+
+      # Note: This is restricted to update only since the attribute value is not
+      # generated until we save the model the first time. The around_save
+      # callback happens after validation, but before saving, so we need to make
+      # it past validation at least one time before checking for a valid code.
+      validates name, uniqueness: uniqueness_options, on: :update
+      validates name, presence: true, on: :update
+
+      # Assign all unique attributes when saving.
+      # Note that even if we call unique_attribute more than once within a
+      # class, Rails only runs this around_save logic once per save, so we
+      # therefore need the around_save logic to handle *all* unique attributes
+      # (not just the one defined in this method).
+      around_save :save_with_unique_attributes
+    end
+
+    private
+
+    # @return [Hash] the subset of the unique attributes hash for which we have
+    #   no values set.
+    def blank_unique_attributes
+      self.class.unique_attributes.select { |k| send(k).nil? }
+    end
+
+    # Ensures that the attribute value exists and is unique (relying on a
+    # database-level unique index) when saving. This will set the value on the
+    # first save of the object.
+    def save_with_unique_attributes
+      blank_attrs = blank_unique_attributes
+
+      # If we have blank unique attributes.
+      if blank_attrs.size > 0
+        attempts = 0
+
+        # Keep retrying until the save works.
+        while !self.persisted?
+          attempts += 1 # Keep track of the number of times we've tried to save.
+
+          # Set each of the blank attributes with the given blocks.
+          blank_attrs.each { |attr, block| write_attribute(attr, block.call) }
+
+          begin
+            ActiveRecord::Base.transaction(requires_new: true) do
+              yield # Perform the save, and see if it works.
+            end
+          rescue ActiveRecord::RecordNotUnique => error
+            attr_group = "(?<attr>#{blank_attrs.keys.join('|')})"
+            other_fields = "(, [\\w`'\"]+)*"
+            sqlite3_regex = /column(s)? #{attr_group}#{other_fields} (is|are) not unique/
+            postgresql_regex = /Key \(#{attr_group}#{other_fields}\)=\([\w\s,]*\) already exists/
+
+            match = sqlite3_regex.match(error.message) ||
+                    postgresql_regex.match(error.message)
+
+            # If we've managed to hit the same unique attribute of a record
+            # already in the database, then we should wipe the attribute and try
+            # again, unless we've already done this many times in which case we
+            # should let the error bubble up.
+            if match && attempts <= SAVE_ATTEMPTS_LIMIT
+              attr = match[:attr].to_sym
+              blank_attrs = { attr => blank_attrs[attr] }
+              write_attribute(attr, nil)
+            else
+              raise error # If something else went wrong, let it propagate.
+            end
+          end
+        end
+      else # If the unique values are already set, perform a regular save.
+        yield
+      end
+    end
+  end
+end

data/lib/unique_attributes/version.rb

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

data/spec/config/database.yml

@@ -0,0 +1,9 @@
+sqlite3_test:
+  adapter: sqlite3
+  database: ":memory:"
+  timeout: 500
+
+postgresql_test:
+  adapter: postgresql
+  database: unique_attributes_test
+  username: postgres

data/spec/config/test_setup_migration.rb

@@ -0,0 +1,38 @@
+class TestSetupMigration < ActiveRecord::Migration
+  def up
+    return if ActiveRecord::Base.connection.table_exists? :test_classes
+
+    create_table :test_classes do |t|
+      t.string :autogenerated_username
+      t.string :other_field, null: false
+    end
+    add_index :test_classes, :autogenerated_username, unique: true
+    add_index :test_classes, :other_field, unique: true
+
+    create_table :scoped_test_classes do |t|
+      t.string :autogenerated_username
+      t.string :other_field
+    end
+    add_index :scoped_test_classes,
+              [:autogenerated_username, :other_field],
+              unique: true,
+              name: :scoped_uniq_indx
+
+    create_table :multiattribute_test_classes do |t|
+      t.string :autogenerated_username
+      t.string :autogenerated_password
+    end
+    add_index :multiattribute_test_classes,
+              :autogenerated_username,
+              unique: true
+    add_index :multiattribute_test_classes,
+              :autogenerated_password,
+              unique: true
+  end
+
+  def down
+    drop_table :test_classes
+    drop_table :scoped_test_classes
+    drop_table :multiattribute_test_classes
+  end
+end

data/spec/postgresql_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+require "shared/unique_attributes_examples"
+
+RSpec.describe "PostgreSQL" do
+  before :all do
+    ActiveRecord::Base.establish_connection(:postgresql_test)
+    TestSetupMigration.migrate(:up)
+  end
+
+  include_examples ".unique_attribute"
+
+  after :all do
+    ActiveRecord::Base.remove_connection
+  end
+end

data/spec/shared/unique_attributes_examples.rb

@@ -0,0 +1,113 @@
+require "spec_helper"
+
+require "support/multiattribute_test_class"
+require "support/scoped_test_class"
+require "support/test_class"
+
+RSpec.shared_examples ".unique_attribute" do
+  let(:obj1) { TestClass.new(other_field: "Foo") }
+  let(:obj2) { TestClass.new(other_field: "Bar") }
+
+  it "generates a value when saving" do
+    obj1.save!
+    expect(obj1.autogenerated_username).to_not be_nil
+  end
+
+  it "does not overwrite a value that is manually set" do
+    obj1.autogenerated_username = "Dummy"
+    expect(obj1.autogenerated_username).to eq "Dummy"
+  end
+
+  it "does not generate a new value when saved multiple times" do
+    obj1.save!
+    val = obj1.autogenerated_username
+
+    obj1.other_field = "A" # Set another field to force the object to save.
+    obj1.save!
+
+    # Check that the autogenerated field doesn't change.
+    expect(obj1.autogenerated_username).to eq val
+  end
+
+  it "generates a new value if the one generated is already taken" do
+    allow(TestClass).to receive(:generate_username).and_return("1", "1", "2")
+
+    obj1.save!
+    obj2.save!
+
+    expect(obj1.autogenerated_username).to eq "1"
+    expect(obj2.autogenerated_username).to eq "2"
+  end
+
+  it "raises an error if updated to an existing one" do
+    obj1.save!
+    obj2.save!
+
+    # Update obj2's value to obj1's to create a uniqueness collision.
+    obj2.autogenerated_username = obj1.autogenerated_username
+
+    expect { obj2.save! }.to raise_error(ActiveRecord::RecordInvalid)
+  end
+
+  it "respects the scope argument" do
+    allow(ScopedTestClass).to receive(:generate_username).
+      and_return("1", "1", "1", "1", "2")
+
+    obj1 = ScopedTestClass.create!(other_field: "A")
+    obj2 = ScopedTestClass.create!(other_field: "B")
+    obj3 = ScopedTestClass.create!(other_field: "A")
+
+    expect(obj1.autogenerated_username).to eq "1"
+    expect(obj2.autogenerated_username).to eq "1"
+    expect(obj3.autogenerated_username).to eq "2"
+  end
+
+  it "does not retry the save when an unrelated uniqueness violation occurs" do
+    expect(TestClass).to receive(:generate_username).
+      exactly(2).times.
+      and_call_original
+
+    obj1.save!
+    obj2.other_field = obj1.other_field
+
+    # This will raise an error because a database unique index ensures that
+    # other_field is unique.
+    expect { obj2.save! }.to raise_error(ActiveRecord::RecordNotUnique)
+  end
+
+  it "raises the error when an unrelated non-uniqueness error occurs" do
+    obj1.other_field = nil
+
+    # This will raise an error because a database constraint ensures that
+    # other_field is not NULL.
+    expect { obj1.save! }.to raise_error(ActiveRecord::StatementInvalid)
+  end
+
+  it "raises the unique violation error if we've tried saving too many times" do
+    # Stub out the username generation function to always cause collisions.
+    allow(TestClass).to receive(:generate_username).and_return("1")
+
+    obj1.save!
+
+    # After retrying the save many times, we will eventually raise an error.
+    expect { obj2.save! }.to raise_error(ActiveRecord::RecordNotUnique)
+  end
+
+  context "when model has multiple unique_attribute fields" do
+    it "only retries fields as needed" do
+      # We stub the username/password generation such that the first two
+      # usernames generated collide but the passwords do not. We use
+      # expectations to ensure that the username is re-generated but the
+      # password is not.
+      expect(MultiattributeTestClass).to receive(:generate_username).
+        exactly(3).times.
+        and_return("1", "1", "2")
+      expect(MultiattributeTestClass).to receive(:generate_password).
+        exactly(2).times.
+        and_return("A", "B")
+
+      MultiattributeTestClass.create!
+      MultiattributeTestClass.create!
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,55 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require "active_record"
+require "database_cleaner"
+
+require "unique_attributes"
+
+ActiveRecord::Base.configurations = YAML.load_file("spec/config/database.yml")
+
+RSpec.configure do |config|
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Roll back the changes to the database after each test.
+  config.around(:each) do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

data/spec/sqlite3_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+require "shared/unique_attributes_examples"
+require "config/test_setup_migration"
+
+RSpec.describe "SQLite3" do
+  before :all do
+    ActiveRecord::Base.establish_connection(:sqlite3_test)
+    TestSetupMigration.migrate(:up)
+  end
+
+  include_examples ".unique_attribute"
+
+  after :all do
+    ActiveRecord::Base.remove_connection
+  end
+end

data/spec/support/multiattribute_test_class.rb

@@ -0,0 +1,13 @@
+class MultiattributeTestClass < ActiveRecord::Base
+  include UniqueAttributes
+  unique_attribute :autogenerated_username, proc { generate_username }
+  unique_attribute :autogenerated_password, proc { generate_password }
+
+  def self.generate_username
+    SecureRandom.hex
+  end
+
+  def self.generate_password
+    SecureRandom.hex
+  end
+end

data/spec/support/scoped_test_class.rb

@@ -0,0 +1,10 @@
+class ScopedTestClass < ActiveRecord::Base
+  include UniqueAttributes
+  unique_attribute :autogenerated_username,
+                   proc { generate_username },
+                   scope: :other_field
+
+  def self.generate_username
+    SecureRandom.hex
+  end
+end

data/spec/support/test_class.rb

@@ -0,0 +1,8 @@
+class TestClass < ActiveRecord::Base
+  include UniqueAttributes
+  unique_attribute :autogenerated_username, proc { generate_username }
+
+  def self.generate_username
+    SecureRandom.hex
+  end
+end

data/spec/unique_attributes_spec.rb

@@ -0,0 +1,4 @@
+# Instead of defining specs here, we define them in
+# shared/unique_attributes_examples.rb. We then have a different spec file for
+# each supported database adapter, whch runs the shared RSpec tests found in
+# the shared/unique_attributes_examples.rb file.

data/unique_attributes.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "unique_attributes/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "unique_attributes"
+  spec.version       = UniqueAttributes::VERSION
+  spec.authors       = ["Jacob Evelyn"]
+  spec.email         = ["jevelyn@panoramaed.com"]
+  spec.summary       = "Auto-assign unique attributes for ActiveRecord objects."
+  spec.description   = "Easily set ActiveRecord attributes to auto-generate "\
+    "as unique values from a given proc."
+  spec.homepage      = "https://www.github.com/panorama-ed/unique_attributes"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", "~> 4.0"
+  spec.add_dependency "activesupport", "~> 4.0"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "codeclimate-test-reporter", "~> 0.4"
+  spec.add_development_dependency "database_cleaner", "~> 1.4"
+  spec.add_development_dependency "overcommit", "~> 0.21"
+  spec.add_development_dependency "pg", "~> 0.18"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1"
+  spec.add_development_dependency "rspec-mocks", "~> 3.1"
+  spec.add_development_dependency "rubocop", "~> 0.28"
+  spec.add_development_dependency "sqlite3", "~> 1.3"
+end

metadata

@@ -0,0 +1,244 @@
+--- !ruby/object:Gem::Specification
+name: unique_attributes
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jacob Evelyn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !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: overcommit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !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.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.28'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.28'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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: Easily set ActiveRecord attributes to auto-generate as unique values
+  from a given proc.
+email:
+- jevelyn@panoramaed.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .overcommit.yml
+- .rubocop.yml
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/unique_attributes.rb
+- lib/unique_attributes/version.rb
+- spec/config/database.yml
+- spec/config/test_setup_migration.rb
+- spec/postgresql_spec.rb
+- spec/shared/unique_attributes_examples.rb
+- spec/spec_helper.rb
+- spec/sqlite3_spec.rb
+- spec/support/multiattribute_test_class.rb
+- spec/support/scoped_test_class.rb
+- spec/support/test_class.rb
+- spec/unique_attributes_spec.rb
+- unique_attributes.gemspec
+homepage: https://www.github.com/panorama-ed/unique_attributes
+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: Auto-assign unique attributes for ActiveRecord objects.
+test_files:
+- spec/config/database.yml
+- spec/config/test_setup_migration.rb
+- spec/postgresql_spec.rb
+- spec/shared/unique_attributes_examples.rb
+- spec/spec_helper.rb
+- spec/sqlite3_spec.rb
+- spec/support/multiattribute_test_class.rb
+- spec/support/scoped_test_class.rb
+- spec/support/test_class.rb
+- spec/unique_attributes_spec.rb