proposal 0.0.1

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Proposal'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/app/models/proposal/token.rb

@@ -0,0 +1,184 @@
+module Proposal
+  class Token < ActiveRecord::Base
+
+    belongs_to :resource,
+      polymorphic: true
+
+    attr_accessible :email,
+      :proposable,
+      :proposable_type,
+      :expires,
+      :expects,
+      :resource,
+      :args
+
+    attr_writer :expects
+
+    validates_presence_of :email,
+      :token,
+      :proposable,
+      :proposable_type,
+      :expires_at
+
+    validates_with ::Proposal::ArgumentsValidator, if: -> {
+      expects.present?
+    }
+
+    validates_with ::Proposal::EmailValidator
+
+    serialize :arguments
+
+    validates :email,
+      uniqueness: {
+        scope: [
+          :proposable_type,
+          :resource_type,
+          :resource_id
+        ],
+        message: "already has an outstanding proposal"
+      }
+
+    before_validation on: :create do
+      self.token = SecureRandom.base64(15).tr('+/=lIO0', 'pqrsxyz')
+    end
+
+    before_validation on: :create do
+      self.expires_at = Time.now + 1.year unless self.expires_at
+    end
+
+    def expects
+      @expects || proposable.proposal_options[:expects]
+    end
+
+    def proposable
+      @proposable ||= self.proposable_type.constantize
+    end
+
+    def proposable= type
+      self.proposable_type = type.to_s
+    end
+
+    def recipient!
+      raise Proposal::RecordNotFound if recipient.nil?
+      recipient
+    end
+
+    def recipient
+      @recipient ||= self.proposable.where(email: self.email).first
+    end
+
+    def self.find_or_new options
+      constraints = options.slice :email, :proposable_type
+      resource = options[:resource]
+      if !resource.nil? && resource.respond_to?(:id)
+        constraints.merge! resource_type: resource.class.to_s,
+          resource_id: resource.id
+      end
+      token = where(constraints).first
+      token.nil? ? new(options) : token
+    end
+
+    def args= args_array
+      if args_array.first.is_a?(Hash) && args_array.size == 1
+        self.arguments = args_array.first
+      else
+        self.arguments = args_array
+      end
+      self
+    end
+
+    def args
+      self.arguments
+    end
+
+    def action
+      case
+        when persisted?
+          :remind
+        when recipient.nil?
+          :invite
+        else
+          :notify
+      end
+    end
+
+    def notify?
+      action == :notify
+    end
+
+    def invite?
+      action == :invite
+    end
+
+    def remind?
+      action == :remind
+    end
+
+    def accepted?
+      !accepted_at.nil?
+    end
+
+    def expired?
+      Time.now >= self.expires_at
+    end
+
+    def self.pending
+      where('accepted_at IS NULL')
+    end
+
+    def self.accepted
+      where('accepted_at IS NOT NULL')
+    end
+
+    def self.expired
+      where('expires_at < ?', Time.now)
+    end
+
+    def self.reminded
+      where('reminded_at IS NOT NULL')
+    end
+
+    def expires= expires_proc
+      unless expires_proc.is_a? Proc
+        raise ArgumentError, 'expires must be a proc'
+      end
+      self.expires_at = expires_proc.call
+    end
+
+    def acceptable?
+      errors.add :token, "has expired" if expired?
+      errors.add :token, "has been accepted" if accepted?
+      !expired? && !accepted?
+    end
+
+    def reminded
+      touch :reminded_at if remind?
+      remind?
+    end
+
+    def reminded!
+      raise Proposal::RemindError, 'proposal has not been made' unless remind?
+      reminded
+    end
+
+    def accept
+      if acceptable?
+        touch :accepted_at
+        true
+      else
+        false
+      end
+    end
+
+    def accept!
+      raise Proposal::ExpiredError, 'token has expired' if expired?
+      raise Proposal::AccepetedError, 'token has been used' if accepted?
+      touch :accepted_at
+      true
+    end
+
+    def to_s
+      token
+    end
+  end
+end

data/app/validators/proposal/arguments_validator.rb

@@ -0,0 +1,36 @@
+module Proposal
+  class ArgumentsValidator < ActiveModel::Validator
+
+    def validate_expected record, sym
+      unless record.arguments[sym].present?
+        record.errors.add :arguments, "is missing #{sym}"
+      end
+    end
+
+    def validate record
+      if record.expects.is_a? Proc
+        unless record.expects.call(record.arguments)
+          record.errors.add :arguments, "is invalid"
+        end
+      elsif record.arguments.is_a? Hash
+        case record.expects
+        when Symbol
+          validate_expected record, record.expects
+        when Array
+          record.expects.each { |sym| validate_expected record, sym }
+        end
+      else
+        record.errors.add :arguments, "must be a hash"
+        case record.expects
+        when Symbol
+          record.errors.add :arguments, "is missing #{record.expects}"
+        when Array
+          record.expects.each do |sym|
+            record.errors.add :arguments, "is missing #{sym}"
+          end
+        end
+      end
+    end
+
+  end
+end

data/app/validators/proposal/email_validator.rb

@@ -0,0 +1,11 @@
+module Proposal
+  class EmailValidator < ActiveModel::Validator
+
+    def validate record
+      unless record.email =~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i
+        record.errors.add :email, "is not valid"
+      end
+    end
+
+  end
+end

data/db/migrate/20121026005348_create_proposal_tokens.rb

@@ -0,0 +1,33 @@
+class CreateProposalTokens < ActiveRecord::Migration
+  def up
+    create_table :proposal_tokens do |t|
+      t.string  :token,           null: false
+      t.string  :email,           null: false
+      t.string  :proposable_type, null: false
+      t.string  :resource_type
+      t.integer :resource_id
+      t.text    :arguments
+
+      t.datetime :accepted_at
+      t.datetime :reminded_at
+      t.datetime :expires_at,     null: false
+      t.datetime :updated_at,     null: false
+      t.datetime :created_at,     null: false
+    end
+
+    add_index :proposal_tokens, :token, unique: true
+
+    execute <<-SQL
+CREATE UNIQUE INDEX proposal_idx ON proposal_tokens (
+  email,
+  proposable_type,
+  resource_type,
+  resource_id
+)
+    SQL
+  end
+
+  def down
+    drop_table :proposal_tokens
+  end
+end

data/lib/proposal.rb

@@ -0,0 +1,5 @@
+require "proposal/engine"
+
+module Proposal
+
+end

data/lib/proposal/engine.rb

@@ -0,0 +1,101 @@
+module Proposal
+
+  class ExpiredError < StandardError; end
+
+  class AccepetedError < StandardError; end
+
+  class RemindError < StandardError; end
+
+  class RecordNotFound < StandardError; end
+
+  # Wrapper object for the ORM. In this case it only supports ActiveRecord. In
+  # theory you could write an Adapter for each different ORM then use the rails
+  # initializer to add.
+  class Adapter
+    def initialize options
+      @options = options
+    end
+
+    def with *args
+      @options.merge! args: args
+      self
+    end
+
+    alias :with_args :with
+
+    # Method to return in instantiate the proposal object using an email
+    # address.
+    def to email, options = {}
+      Token.find_or_new @options.merge(options).merge email: email
+    end
+
+    # Delegates to ORM object and returns all proposal objects for given type.
+    def self.where options
+      Token.where options
+    end
+  end
+
+  module CanPropose
+
+    # Module for adding in class methods to object. For example:
+    #
+    # ==== Example
+    #
+    #    User < ActiveRecord::Base
+    #      can_propose
+    #    end
+    #
+    module ClassMethods
+
+      # Class method for configuring default behaviour in ORM object.
+      #
+      # ==== Options
+      #
+      # * +:expires+ - A proc that returns a +DateTime+"
+      # * +:expects+ - Symbol or array of expected keys in arguments"
+      def can_propose options = {}
+        @proposal_options = options.merge proposable_type: self.to_s
+      end
+
+      # Getter for +@proposal_options+
+      def proposal_options
+        @proposal_options
+      end
+
+      # Class method for returning a new instance of +Adapter+
+      #
+      # Optional +resource+ argument that the ORM stores a reference to. This
+      # enables the email address to have multiple proposals for different
+      # unique resources.
+      def propose resource = nil
+        Adapter.new @proposal_options.merge resource: resource
+      end
+
+      # Delegate method to return all the proposals for the ORM object.
+      def proposals
+        Adapter.where proposable_type: self.to_s
+      end
+    end
+
+    module InstanceMethods
+      def proposals
+        Adapter.where resource_type: self.class.to_s, resource_id: self.id
+      end
+    end
+
+    def self.included base
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+    end
+  end
+
+  class Engine < ::Rails::Engine
+    isolate_namespace Proposal
+
+    initializer "proposal.configure" do |app|
+      ActiveSupport.on_load :active_record do
+        include CanPropose
+      end
+    end
+  end
+end

data/lib/proposal/version.rb

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

data/lib/tasks/proposal_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :proposal do
+#   # Task goes here
+# end

data/test/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/test/dummy/app/models/project.rb

@@ -0,0 +1,3 @@
+class Project < ActiveRecord::Base
+  # attr_accessible :title, :body
+end

data/test/dummy/app/models/user.rb

@@ -0,0 +1,5 @@
+class User < ActiveRecord::Base
+  attr_accessible :email
+
+  can_propose expires: -> { Time.now + 1.day }
+end