fraternity 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 368f6c901620e8bfbcbc5629d415e279065d4256
+  data.tar.gz: 69c4ce243b0eced4e297b46209a9ae4928bfb555
+SHA512:
+  metadata.gz: 369a256c3764c6f2b86730b79d06c913221cee6663ea948f537f17f889bc4babfde4a9f9ed28f1142935e9030e1c5d65a9fab55659e3e1a4884e612bf8aa0dd0
+  data.tar.gz: cf7db18d627e19eafe6c19b93d0025c6977605891ab975825adeab378277bc978ee4d9dac4bbe8e3a604b4a077f482ad9b83e951f076e09933e980706470504c

data/.coveralls.yml

@@ -0,0 +1 @@
+repo_token: 0434oPH5AmyPXuVPweKtCWtPXgI5ytvyN

data/.gitignore

@@ -0,0 +1 @@
+/coverage

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.2.0

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+ruby '2.2.0'
+
+gemspec
+
+group :development, :test do
+  gem 'rspec'
+  gem 'coveralls'
+  gem 'sqlite3'
+end

data/Gemfile.lock

@@ -0,0 +1,62 @@
+PATH
+  remote: .
+  specs:
+    fraternity (0.0.1)
+      lotus-model
+      lotus-validations
+      rake
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coveralls (0.7.2)
+      multi_json (~> 1.3)
+      rest-client (= 1.6.7)
+      simplecov (>= 0.7)
+      term-ansicolor (= 1.2.2)
+      thor (= 0.18.1)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    lotus-model (0.2.1)
+      lotus-utils (~> 0.3, >= 0.3.2)
+      sequel (~> 4.9)
+    lotus-utils (0.3.3)
+    lotus-validations (0.2.3)
+      lotus-utils (~> 0.3, >= 0.3.3)
+    mime-types (2.4.3)
+    multi_json (1.10.1)
+    rake (10.4.2)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    sequel (4.18.0)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    sqlite3 (1.3.10)
+    term-ansicolor (1.2.2)
+      tins (~> 0.8)
+    thor (0.18.1)
+    tins (0.13.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  coveralls
+  fraternity!
+  rspec
+  sqlite3

data/README.md

@@ -0,0 +1,145 @@
+Fraternity
+==========
+
+[ ![Codeship Status for brilliantfantastic/fraternity](https://codeship.com/projects/3fe0d950-80a4-0132-9038-321707412590/status?branch=master)](https://codeship.com/projects/57522)
+[![Coverage Status](https://coveralls.io/repos/brilliantfantastic/fraternity/badge.svg)](https://coveralls.io/r/brilliantfantastic/fraternity)
+[![Code Climate](https://codeclimate.com/github/brilliantfantastic/fraternity/badges/gpa.svg)](https://codeclimate.com/github/brilliantfantastic/fraternity)
+
+## DESCRIPTION
+
+An easier way to rush for a beta.
+
+A gem allows you to collect and store (using only [the Lotus framework](http://lotusrb.com) as of now) a list of pledges who would like access to your beta. You can send out bids to those pledges and allow them to gain access to your beta.
+
+## INSTALLATION
+
+Add this line to your Gemfile:
+
+```
+gem 'fraternity'
+```
+
+And then execute:
+
+```
+bundle install
+```
+
+Or install it yourself:
+
+```
+gem install fraternity
+```
+
+Create the database table needed:
+
+```
+bundle exec rake fraternity:install DESTINATION="db/migrate"
+```
+
+The above will create the following table.
+
+```
+create_table :pledges do |t|
+  t.primary_key   :id
+  String          :token
+  String          :email
+  String          :first_name
+  String          :last_name
+  Integer         :initiation_number
+  DateTime        :invited_at
+  DateTime        :accepted_at
+end
+```
+
+## USAGE
+
+If you are unfamiliar with the terminology, you can read up at [http://www.unlv.edu/getinvolved/greek-definitions](http://www.unlv.edu/getinvolved/greek-definitions).
+
+### Configuring
+
+In order to use your Fraternity, you have to configure it before you use it.
+
+```
+Fraternity.configure do |config|
+  configure.database_url = ENV["DATABASE_URL"]
+  configure.send_invite = lambda do |pledge|
+    BetaMailer.invite_email(pledge).deliver
+  end
+end
+```
+
+### Pledging
+
+To sign up pledges, you first need to rush. Collect email addresses (and any additional information) to get in line for membership at the frat house.
+
+```
+params = { email: "jeremy.piven@example.com" } # Optional attributes you want to save such as first_name, last_name, etc.
+pledge = Fraternity.rush! params
+```
+
+The above saves the information to the pledges database and creates a token for a `Pledge`
+
+### Moving up the initiation line
+
+**Coming soon**
+
+### Inviting a new pledge
+
+Send out email invitations to the next set of pledges based on their initiation number. A quota is specified for the number you want to invite.
+
+```
+invited = Fraternity.bid! quota
+```
+
+The above saves the date/time of the invite to all the invited pledges and returns an array of the invited.
+
+The above will also call the `send_invite` proc that you have set up in the configuration. You are responsible for sending the invite to the pledge any way you like.
+
+Find out if a pledge has been invited
+
+```
+Fraternity::Pledge.find(123).invited?
+```
+
+Resend an invite
+
+```
+Fraternity::Pledge.find(123).bid!
+```
+
+### Accepting a pledge
+
+Check to see if a pledge is ready to be crossed into a full time member (invited and not crossed)
+
+```
+Fraternity::Pledge.find(token).ready?
+```
+
+Check to see if a pledge has been crossed into a full member
+
+```
+Fraternity::Pledge.find(token).crossed?
+```
+
+Convert the pledge into a full member (accept the invitation).
+
+```
+Fraternity::Pledge.cross! token
+```
+
+## CONTRIBUTING
+
+1. Clone the repository `git clone https://github.com/brilliantfantastic/fraternity`
+1. Create a feature branch `git checkout -b my-awesome-feature`
+1. Codez!
+1. Commit your changes (small commits please)
+1. Push your new branch `git push origin my-awesome-feature`
+1. Create a pull request `hub pull-request -b brilliantfantastic:master -h brilliantfantastic:my-awesome-feature`
+
+## RELEASING A NEW GEM
+
+1. Bump the VERSION in `lib/fraternity/version.rb`
+1. Commit changes and push to GitHub
+1. run `bundle exec rake build`
+1. run `bundle exec rake release`

data/Rakefile

@@ -0,0 +1,29 @@
+require 'bundler/gem_tasks'
+
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new(:spec)
+  task default: :spec
+rescue LoadError
+end
+
+require 'coveralls/rake/task'
+Coveralls::RakeTask.new
+
+namespace :fraternity do
+  task :install do
+    # read the migration
+    base_file_name = "create_pledges.rb"
+    template = File.join File.dirname(__FILE__), "lib/generators/fraternity/templates/migration", base_file_name
+    contents = File.open(template) { |f| f.read }
+
+    # create the migration
+    destination = ENV["DESTINATION"] || "."
+    unless File.directory?(destination)
+      FileUtils.mkdir_p destination
+    end
+    timestamp = Time.now.to_i
+    destination_file = File.join destination, "#{timestamp}_#{base_file_name}"
+    File.open(destination_file, 'w') { |f| f.write(contents) }
+  end
+end

data/fraternity.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fraternity/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "fraternity"
+  spec.version       = Fraternity::VERSION
+
+  spec.authors       = ["Jamie Wright"]
+  spec.email         = ["jamie@brilliantfantastic.com"]
+
+  spec.summary       = "An easier way to rush for a beta"
+  spec.description   = %q{
+                        Collect and store a list of pledges who would like access to your beta. You can send out bids to those
+                        pledges and allow them to gain access to your beta.
+                       }
+
+  spec.homepage      = "http://github.com/brilliantfantastic/fraternity"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rake"
+  spec.add_dependency "lotus-model"
+  spec.add_dependency "lotus-validations"
+end

data/lib/fraternity/bidder.rb

@@ -0,0 +1,14 @@
+module Fraternity
+  class Bidder
+    def initialize(pledge)
+      @pledge = pledge
+    end
+
+    def bid!
+      @pledge.invite!
+      Repositories::PledgeRepository.persist @pledge
+      Fraternity.configuration.send_invite.call @pledge
+      @pledge
+    end
+  end
+end

data/lib/fraternity/configuration.rb

@@ -0,0 +1,9 @@
+module Fraternity
+  class Configuration
+    attr_accessor :database_url, :send_invite
+
+    def initialize
+      @send_invite = lambda { |pledge| pledge }
+    end
+  end
+end

data/lib/fraternity/perp_error.rb

@@ -0,0 +1,3 @@
+module Fraternity
+  class PerpError < StandardError; end
+end

data/lib/fraternity/pledge.rb

@@ -0,0 +1,45 @@
+require "lotus/validations"
+
+module Fraternity
+  class Pledge
+    include Lotus::Validations
+
+    attr_accessor :id, :email, :first_name, :last_name, :token, :initiation_number, :invited_at, :accepted_at
+
+    validates :email, presence: true, format: /[-0-9a-zA-Z.+_]+@[-0-9a-zA-Z.+_]+\.[a-zA-Z]{2,4}/
+    validates :token, presence: true
+    validates :initiation_number, presence: true
+
+    def initialize(attributes={})
+
+      @id, @email, @first_name, @last_name, @token, @initiation_number, @invited_at, @accepted_at =
+        attributes.values_at :id, :email, :first_name, :last_name, :token, :initiation_number, :invited_at, :accepted_at
+    end
+
+    def bid!
+      Bidder.new(self).bid!
+    end
+
+    def invite!
+      self.invited_at = DateTime.now
+    end
+
+    def invited?
+      !self.invited_at.nil?
+    end
+
+    def cross!(token)
+      raise Fraternity::PerpError if !invited?
+      raise Fraternity::TokenMismatchError.new(self.token, token) if token != self.token
+      self.accepted_at = DateTime.now
+    end
+
+    def crossed?
+      !self.accepted_at.nil?
+    end
+
+    def ready?
+      self.invited? && !self.crossed?
+    end
+  end
+end

data/lib/fraternity/repositories/pledge_repository.rb

@@ -0,0 +1,28 @@
+require 'lotus/repository'
+
+module Fraternity
+  module Repositories
+    class PledgeRepository
+      include Lotus::Repository
+
+      def self.find_by_id(id)
+        query do
+          where(id: id)
+        end.first
+      end
+
+      def self.find_by_token(token)
+        query do
+          where(token: token)
+        end.first
+      end
+
+      def self.oldest_uninvited_by_initiation_number(limit=8)
+        query do
+          where(invited_at: nil).
+            order(:initiation_number)
+        end.limit(limit)
+      end
+    end
+  end
+end

data/lib/fraternity/repositories.rb

@@ -0,0 +1,33 @@
+require "lotus/model/mapper"
+require "lotus/model/adapters/sql_adapter"
+require_relative "repositories/pledge_repository"
+
+module Fraternity
+  module Repositories
+    @@mapping = Lotus::Model::Mapper.new do
+      collection :pledges do
+        entity Fraternity::Pledge
+        repository PledgeRepository
+
+        attribute :id,                  Integer
+        attribute :email,               String
+        attribute :first_name,          String
+        attribute :last_name,           String
+        attribute :token,               String
+        attribute :initiation_number,   Integer
+        attribute :invited_at,          DateTime
+        attribute :accepted_at,         DateTime
+      end
+    end
+
+    def self.mapping
+      @@mapping
+    end
+
+    def self.initiation!(database_url)
+      adapter = Lotus::Model::Adapters::SqlAdapter.new(mapping, database_url)
+      PledgeRepository.adapter = adapter
+      mapping.load!
+    end
+  end
+end

data/lib/fraternity/temporary_token.rb

@@ -0,0 +1,9 @@
+require 'securerandom'
+
+module Fraternity
+  class TemporaryToken
+    def self.generate_random_token
+      SecureRandom.base64(15).tr('+/=lIO0', 'pqrsxyz')
+    end
+  end
+end

data/lib/fraternity/token_mismatch_error.rb

@@ -0,0 +1,7 @@
+module Fraternity
+  class TokenMismatchError < StandardError
+    def initialize(expected_token, actual_token)
+      super "Expected token #{expected_token}, but was #{actual_token}"
+    end
+  end
+end

data/lib/fraternity/version.rb

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

data/lib/fraternity.rb

@@ -0,0 +1,42 @@
+require "fraternity/version"
+require "fraternity/bidder"
+require "fraternity/configuration"
+require "fraternity/perp_error"
+require "fraternity/pledge"
+require "fraternity/repositories"
+require "fraternity/temporary_token"
+require "fraternity/token_mismatch_error"
+
+module Fraternity
+  def self.configuration
+    @configuration ||= Fraternity::Configuration.new
+  end
+
+  def self.configure(initiate=true)
+    yield configuration if block_given?
+    Repositories.initiation! configuration.database_url if initiate
+  end
+
+  def self.rush(params={})
+    params[:token] ||= TemporaryToken.generate_random_token
+    params[:initiation_number] ||= Time.now.to_i
+    Fraternity::Pledge.new params
+  end
+
+  def self.rush!(params)
+    Repositories::PledgeRepository.create self.rush(params)
+  end
+
+  def self.bid!(quota)
+    Repositories::PledgeRepository.oldest_uninvited_by_initiation_number(quota).collect do |pledge|
+      pledge.bid!
+    end
+  end
+
+  def self.find(identifier)
+    if identifier.is_a? Integer
+      return Repositories::PledgeRepository.find_by_id identifier
+    end
+    Repositories::PledgeRepository.find_by_token identifier
+  end
+end

data/lib/generators/fraternity/templates/migration/create_pledges.rb

@@ -0,0 +1,14 @@
+Sequel.migration do
+  change do
+    create_table :pledges do
+      primary_key :id
+      String      :token
+      String      :email
+      String      :first_name
+      String      :last_name
+      Integer     :initiation_number
+      DateTime    :invited_at
+      DateTime    :accepted_at
+    end
+  end
+end

data/spec/fraternity/configuration_spec.rb

@@ -0,0 +1,6 @@
+describe Fraternity::Configuration do
+  it "has a default send_invite proc" do
+    configuration = Fraternity::Configuration.new
+    expect { configuration.send_invite.call(nil) }.to_not raise_error
+  end
+end

data/spec/fraternity/pledge_spec.rb

@@ -0,0 +1,105 @@
+describe Fraternity::Pledge do
+  describe "validations" do
+    it "requires an email address" do
+      pledge = Fraternity::Pledge.new
+      expect(pledge).to_not be_valid
+      expect(pledge.errors.for(:email).first.validation).to eq :presence
+    end
+
+    it "requires a valid email address" do
+      pledge = Fraternity::Pledge.new email: "blah@test"
+      expect(pledge).to_not be_valid
+      expect(pledge.errors.for(:email).first.validation).to eq :format
+    end
+
+    it "requires a token" do
+      pledge = Fraternity::Pledge.new email: "jimmy@example.com", token: ""
+      expect(pledge).to_not be_valid
+      expect(pledge.errors.for(:token).first.validation).to eq :presence
+    end
+
+    it "requires an initiation number" do
+      pledge = Fraternity::Pledge.new email: "jimmy@example.com", token: "123456", initiation_number: ""
+      expect(pledge).to_not be_valid
+      expect(pledge.errors.for(:initiation_number).first.validation).to eq :presence
+    end
+  end
+
+  describe "#invited?" do
+    it "is not invited if the date and time when they were invited is not set" do
+      pledge = Fraternity::Pledge.new
+      expect(pledge).to_not be_invited
+    end
+
+    it "is invited if the date and time when they were invited is set" do
+      pledge = Fraternity::Pledge.new invited_at: DateTime.now
+      expect(pledge).to be_invited
+    end
+  end
+
+  describe "#invite!" do
+    it "sets the date and time of when the pledge was invited to the current date and time" do
+      pledge = Fraternity::Pledge.new
+      pledge.invite!
+      expect(pledge).to be_invited
+    end
+  end
+
+  describe "#crossed?" do
+    it "is not crossed if they have not accepted the invitation" do
+      pledge = Fraternity::Pledge.new
+      expect(pledge).to_not be_crossed
+    end
+
+    it "is crossed if they have accepted the invitation" do
+      pledge = Fraternity::Pledge.new accepted_at: DateTime.now
+      expect(pledge).to be_crossed
+    end
+  end
+
+  describe "#cross!" do
+    it "sets the date and time of when the pledge has accepted the invite to the current date and time" do
+      token = "12345"
+      pledge = Fraternity::Pledge.new token: token, invited_at: DateTime.now
+      pledge.cross! token
+      expect(pledge).to be_crossed
+    end
+
+    it "does not cross over if the token does not match" do
+      pledge = Fraternity::Pledge.new token: "12345", invited_at: DateTime.now
+      expect { pledge.cross! "blah" }.to raise_error Fraternity::TokenMismatchError
+    end
+
+    it "does not cross over if the pledge was not invited" do
+      token = "12345"
+      pledge = Fraternity::Pledge.new token: token
+      expect { pledge.cross! token }.to raise_error Fraternity::PerpError
+    end
+  end
+
+  describe "#bid!" do
+    it "updates the date and time they were invited" do
+      pledge = Fraternity::Pledge.new id: 123, token: "12345", email: "jimmy@example.com", invited_at: DateTime.new(2015, 1, 18)
+      allow(Fraternity::Repositories::PledgeRepository).to receive(:persist).and_return pledge
+      pledge.bid!
+      expect(((DateTime.now - pledge.invited_at) * 24 * 60 * 60).to_i).to be < 1
+    end
+  end
+
+  describe "#ready?" do
+    it "returns true if the pledge is invited but not yet crossed" do
+      pledge = Fraternity::Pledge.new token: "1234", invited_at: DateTime.now
+      expect(pledge).to be_ready
+    end
+
+    it "is not ready if they have not been invited" do
+      pledge = Fraternity::Pledge.new token: "1234"
+      expect(pledge).to_not be_ready
+    end
+
+    it "is not ready if they have crossed" do
+      pledge = Fraternity::Pledge.new token: "1234", invited_at: DateTime.now, accepted_at: DateTime.now
+      expect(pledge).to_not be_ready
+    end
+  end
+end

data/spec/fraternity/repositories/pledge_repository_spec.rb

@@ -0,0 +1,56 @@
+describe Fraternity::Repositories::PledgeRepository do
+  before { load_repositories! }
+
+  describe ".find_by_token" do
+    let(:token) { "YUSGH764" }
+    let(:pledge) { Fraternity::Repositories::PledgeRepository.create(Fraternity::Pledge.new(email: "jimmy@example.com", token: token, initiation_number: Time.now.to_i)) }
+
+    it "returns the first pledge with the token" do
+      pledge
+      actual = Fraternity::Repositories::PledgeRepository.find_by_token token
+      expect(actual.id).to eq pledge.id
+    end
+
+    it "returns nil if the pledge does not exist" do
+      actual = Fraternity::Repositories::PledgeRepository.find_by_token "blah"
+      expect(actual).to be_nil
+    end
+  end
+
+  describe ".find_by_id" do
+    let(:pledge) { Fraternity::Repositories::PledgeRepository.create(Fraternity::Pledge.new(email: "jimmy@example.com", token: "12345", initiation_number: Time.now.to_i)) }
+
+    it "returns the first pledge with the id" do
+      pledge
+      actual = Fraternity::Repositories::PledgeRepository.find_by_id pledge.id
+      expect(actual.id).to eq pledge.id
+    end
+
+    it "returns nil if the pledge does not exist" do
+      actual = Fraternity::Repositories::PledgeRepository.find_by_id 123
+      expect(actual).to be_nil
+    end
+  end
+
+  describe ".oldest_univited_by_initiation_number" do
+    let(:four_days_ago) { Time.now.to_i - 24 * 60 * 60 * 4 }
+    let(:six_days_ago) { Time.now.to_i - 24 * 60 * 60 * 6 }
+    let(:ten_days_ago) { Time.now.to_i - 24 * 60 * 60 * 10 }
+
+    let(:oldest_pledge) { Fraternity::Repositories::PledgeRepository.create(Fraternity::Pledge.new(email: "jimmy@example.com", token: "1234", initiation_number: ten_days_ago)) }
+    let(:middle_pledge) { Fraternity::Repositories::PledgeRepository.create(Fraternity::Pledge.new(email: "robert@example.com", token: "5678", initiation_number: six_days_ago)) }
+    let(:newest_pledge) { Fraternity::Repositories::PledgeRepository.create(Fraternity::Pledge.new(email: "john@example.com", token: "9123", initiation_number: four_days_ago)) }
+
+    before { [middle_pledge, newest_pledge, oldest_pledge] } # place in database in this order
+
+    it "returns the oldest pledges based on their initiation number" do
+      pledges = Fraternity::Repositories::PledgeRepository.oldest_uninvited_by_initiation_number
+      expect(pledges.map(&:email)).to eq ["jimmy@example.com", "robert@example.com", "john@example.com"]
+    end
+
+    it "returns a limited number of pledges" do
+      pledges = Fraternity::Repositories::PledgeRepository.oldest_uninvited_by_initiation_number(2)
+      expect(pledges.map(&:email)).to eq ["jimmy@example.com", "robert@example.com"]
+    end
+  end
+end

data/spec/fraternity/repositories_spec.rb

@@ -0,0 +1,8 @@
+describe Fraternity::Repositories do
+  describe ".initiation!" do
+    it "sets the adapters for the repositories to a SQL adapter" do
+      Fraternity::Repositories.initiation! "sqlite://blah.db"
+      expect(Fraternity::Repositories::PledgeRepository.instance_variable_get("@adapter")).to be_instance_of Lotus::Model::Adapters::SqlAdapter
+    end
+  end
+end

data/spec/fraternity/temporary_token_spec.rb

@@ -0,0 +1,9 @@
+describe Fraternity::TemporaryToken do
+  describe ".generate_random_token" do
+    it "generates a unique random token" do
+      tokens = []
+      50.times { tokens << Fraternity::TemporaryToken.generate_random_token }
+      expect(tokens.uniq.length).to eq 50
+    end
+  end
+end

data/spec/fraternity/token_mismatch_error_spec.rb

@@ -0,0 +1,8 @@
+describe Fraternity::TokenMismatchError do
+  it "describes the mismatched tokens" do
+    expected = "1234"
+    actual = "5678"
+    error = Fraternity::TokenMismatchError.new expected, actual
+    (expect(error.message)).to eq "Expected token #{expected}, but was #{actual}"
+  end
+end

data/spec/fraternity_spec.rb

@@ -0,0 +1,99 @@
+describe Fraternity do
+  describe ".bid!" do
+    let(:pledge) { Fraternity::Repositories::PledgeRepository.create(Fraternity::Pledge.new(email: "jimmy@example.com", token: "1234", initiation_number: Time.now.to_i)) }
+
+    before do
+      load_repositories!
+      pledge
+    end
+
+    it "invites the uninvited" do
+      pledges = Fraternity.bid! 5
+      expect(pledges.to_a[0].id).to eq pledge.id
+      expect(pledges.to_a[0]).to be_invited
+    end
+
+    it "sends the invite" do
+      sent_invite = false
+      Fraternity.configure(false) do |c|
+        c.send_invite = lambda do |pledge|
+          sent_invite = true
+        end
+      end
+      pledges = Fraternity.bid! 5
+      expect(sent_invite).to be true
+    end
+  end
+
+  describe ".configure" do
+    it "yields an instance of configuration" do
+      Fraternity.configure(false) do |config|
+        expect(config).to eq Fraternity.configuration
+      end
+    end
+  end
+
+  describe ".find" do
+    let(:token) { "HJDKSYS6782W" }
+    let(:pledge) { Fraternity::Pledge.new id: 123, token: token, email: "jimmy@example.com" }
+
+    it "returns a pledge based on their token" do
+      allow(Fraternity::Repositories::PledgeRepository).to receive(:find_by_token).and_return pledge
+      actual = Fraternity.find token
+      expect(actual.id).to eq pledge.id
+    end
+
+    it "returns a pledge based on their id" do
+      allow(Fraternity::Repositories::PledgeRepository).to receive(:find_by_id).and_return pledge
+      actual = Fraternity.find pledge.id
+      expect(actual.id).to eq pledge.id
+    end
+  end
+
+  describe ".rush" do
+    it "rushes with parameters that describe the pledge" do
+      expect { Fraternity.rush email: "blah" }.to_not raise_error
+    end
+
+    it "creates a new pledge with the specified parameters" do
+      pledge = Fraternity.rush email: "jimmy@example.com"
+      expect(pledge.email).to eq "jimmy@example.com"
+    end
+
+    it "populates a token for the pledge to use for joining" do
+      pledge = Fraternity.rush
+      expect(pledge.token).to_not be_empty
+    end
+
+    it "uses the provided token if there is one" do
+      pledge = Fraternity.rush token: "blah"
+      expect(pledge.token).to eq "blah"
+    end
+
+    it "creates an initiation number" do
+      pledge = Fraternity.rush
+      expect(pledge.initiation_number).to_not be_nil
+      initiated_at = Time.at pledge.initiation_number
+      expect((Time.now - initiated_at).to_i).to be < 1
+    end
+
+    it "uses the provided initiation number if there is one" do
+      pledge = Fraternity.rush initiation_number: 12345
+      expect(pledge.initiation_number).to eq 12345
+    end
+  end
+
+  describe ".rush!" do
+    before { load_repositories! }
+
+    it "creates a new pledge with the specified parameters" do
+      pledge = Fraternity.rush! email: "jimmy@example.com"
+      expect(pledge.email).to eq "jimmy@example.com"
+    end
+
+    it "saves the new pledge to the database" do
+      pledge = Fraternity.rush! email: "jimmy@example.com"
+      expect(pledge.id).to_not be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require 'coveralls'
+Coveralls.wear!
+
+require "fraternity"
+
+ROOT = File.expand_path('../../', __FILE__)
+Dir[File.join(ROOT, 'spec', 'support', '**/*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.profile_examples = 10
+
+  config.order = :random
+  Kernel.srand config.seed
+end

data/spec/support/repository_helper.rb

@@ -0,0 +1,6 @@
+def load_repositories!
+  require "lotus/model/adapters/memory_adapter"
+  mapping = Fraternity::Repositories.mapping
+  Fraternity::Repositories::PledgeRepository.adapter = Lotus::Model::Adapters::MemoryAdapter.new mapping
+  mapping.load!
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: fraternity
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jamie Wright
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: lotus-model
+  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'
+- !ruby/object:Gem::Dependency
+  name: lotus-validations
+  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: "\n                        Collect and store a list of pledges who would
+  like access to your beta. You can send out bids to those\n                        pledges
+  and allow them to gain access to your beta.\n                       "
+email:
+- jamie@brilliantfantastic.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- fraternity.gemspec
+- lib/fraternity.rb
+- lib/fraternity/bidder.rb
+- lib/fraternity/configuration.rb
+- lib/fraternity/perp_error.rb
+- lib/fraternity/pledge.rb
+- lib/fraternity/repositories.rb
+- lib/fraternity/repositories/pledge_repository.rb
+- lib/fraternity/temporary_token.rb
+- lib/fraternity/token_mismatch_error.rb
+- lib/fraternity/version.rb
+- lib/generators/fraternity/templates/migration/create_pledges.rb
+- spec/fraternity/configuration_spec.rb
+- spec/fraternity/pledge_spec.rb
+- spec/fraternity/repositories/pledge_repository_spec.rb
+- spec/fraternity/repositories_spec.rb
+- spec/fraternity/temporary_token_spec.rb
+- spec/fraternity/token_mismatch_error_spec.rb
+- spec/fraternity_spec.rb
+- spec/spec_helper.rb
+- spec/support/repository_helper.rb
+homepage: http://github.com/brilliantfantastic/fraternity
+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: An easier way to rush for a beta
+test_files:
+- spec/fraternity/configuration_spec.rb
+- spec/fraternity/pledge_spec.rb
+- spec/fraternity/repositories/pledge_repository_spec.rb
+- spec/fraternity/repositories_spec.rb
+- spec/fraternity/temporary_token_spec.rb
+- spec/fraternity/token_mismatch_error_spec.rb
+- spec/fraternity_spec.rb
+- spec/spec_helper.rb
+- spec/support/repository_helper.rb