somatics3-generators 0.0.9 → 0.0.10

data/lib/generators/somatics/authenticated/templates/mailer.rb

@@ -1,25 +0,0 @@
-class <%= class_name %>Mailer < ActionMailer::Base
-  def signup_notification(<%= file_name %>)
-    setup_email(<%= file_name %>)
-    @subject    += 'Please activate your new account'
-  <% if options[:include_activation] %>
-    @body[:url]  = "http://YOURSITE/activate/#{<%= file_name %>.activation_code}"
-  <% else %>
-    @body[:url]  = "http://YOURSITE/login/" <% end %>
-  end
-  
-  def activation(<%= file_name %>)
-    setup_email(<%= file_name %>)
-    @subject    += 'Your account has been activated!'
-    @body[:url]  = "http://YOURSITE/"
-  end
-  
-  protected
-    def setup_email(<%= file_name %>)
-      @recipients  = "#{<%= file_name %>.email}"
-      @from        = "ADMINEMAIL"
-      @subject     = "[YOURSITE] "
-      @sent_on     = Time.now
-      @body[:<%= file_name %>] = <%= file_name %>
-    end
-end

data/lib/generators/somatics/authenticated/templates/migration.rb

@@ -1,26 +0,0 @@
-class <%= migration_name %> < ActiveRecord::Migration
-  def self.up
-    create_table "<%= table_name %>", :force => true do |t|
-      t.column :login,                     :string, :limit => 40
-      t.column :name,                      :string, :limit => 100, :default => '', :null => true
-      t.column :email,                     :string, :limit => 100
-      t.column :crypted_password,          :string, :limit => 40
-      t.column :salt,                      :string, :limit => 40
-      t.column :created_at,                :datetime
-      t.column :updated_at,                :datetime
-      t.column :remember_token,            :string, :limit => 40
-      t.column :remember_token_expires_at, :datetime
-<% if options[:include_activation] -%>
-      t.column :activation_code,           :string, :limit => 40
-      t.column :activated_at,              :datetime<% end %>
-<% for attribute in attributes -%>
-      t.<%= attribute.type %> :<%= attribute.name %>
-<% end -%>
-    end
-    add_index :<%= table_name %>, :login, :unique => true
-  end
-
-  def self.down
-    drop_table "<%= table_name %>"
-  end
-end

data/lib/generators/somatics/authenticated/templates/model.rb

@@ -1,83 +0,0 @@
-require 'digest/sha1'
-
-class <%= class_name %> < ActiveRecord::Base
-  include Authentication
-  include Authentication::ByPassword
-  include Authentication::ByCookieToken
-<% if options[:aasm] -%>
-  include Authorization::AasmRoles
-<% elsif options[:stateful] -%>
-  include Authorization::StatefulRoles<% end %>
-  validates_presence_of     :login
-  validates_length_of       :login,    :within => 3..40
-  validates_uniqueness_of   :login
-  validates_format_of       :login,    :with => Authentication.login_regex, :message => Authentication.bad_login_message
-
-  validates_format_of       :name,     :with => Authentication.name_regex,  :message => Authentication.bad_name_message, :allow_nil => true
-  validates_length_of       :name,     :maximum => 100
-
-  validates_presence_of     :email
-  validates_length_of       :email,    :within => 6..100 #r@a.wk
-  validates_uniqueness_of   :email
-  validates_format_of       :email,    :with => Authentication.email_regex, :message => Authentication.bad_email_message
-
-  <% if options[:include_activation] && !options[:stateful] %>before_create :make_activation_code <% end %>
-
-  # HACK HACK HACK -- how to do attr_accessible from here?
-  # prevents a user from submitting a crafted form that bypasses activation
-  # anything else you want your user to change should be added here.
-  attr_accessible :login, :email, :name, :password, :password_confirmation
-
-<% if options[:include_activation] && !options[:stateful] %>
-  # Activates the user in the database.
-  def activate!
-    @activated = true
-    self.activated_at = Time.now.utc
-    self.activation_code = nil
-    save(false)
-  end
-
-  # Returns true if the user has just been activated.
-  def recently_activated?
-    @activated
-  end
-
-  def active?
-    # the existence of an activation code means they have not activated yet
-    activation_code.nil?
-  end<% end %>
-
-  # Authenticates a user by their login name and unencrypted password.  Returns the user or nil.
-  #
-  # uff.  this is really an authorization, not authentication routine.  
-  # We really need a Dispatch Chain here or something.
-  # This will also let us return a human error message.
-  #
-  def self.authenticate(login, password)
-    return nil if login.blank? || password.blank?
-    u = <% if    options[:stateful]           %>find_in_state :first, :active, :conditions => {:login => login.downcase}<%
-           elsif options[:include_activation] %>find :first, :conditions => ['login = ? and activated_at IS NOT NULL', login]<%
-           else %>find_by_login(login.downcase)<% end %> # need to get the salt
-    u && u.authenticated?(password) ? u : nil
-  end
-
-  def login=(value)
-    write_attribute :login, (value ? value.downcase : nil)
-  end
-
-  def email=(value)
-    write_attribute :email, (value ? value.downcase : nil)
-  end
-
-  protected
-    
-<% if options[:include_activation] -%>
-    def make_activation_code
-  <% if options[:stateful] -%>
-      self.deleted_at = nil
-  <% end -%>
-      self.activation_code = self.class.make_token
-    end
-<% end %>
-
-end

data/lib/generators/somatics/authenticated/templates/observer.rb

@@ -1,11 +0,0 @@
-class <%= class_name %>Observer < ActiveRecord::Observer
-  def after_create(<%= file_name %>)
-    <%= class_name %>Mailer.deliver_signup_notification(<%= file_name %>)
-  end
-
-  def after_save(<%= file_name %>)
-  <% if options[:include_activation] %>
-    <%= class_name %>Mailer.deliver_activation(<%= file_name %>) if <%= file_name %>.recently_activated?
-  <% end %>
-  end
-end

data/lib/generators/somatics/authenticated/templates/test/mailer_test.rb

@@ -1,31 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require '<%= file_name %>_mailer'
-
-class <%= class_name %>MailerTest < Test::Unit::TestCase
-  FIXTURES_PATH = File.dirname(__FILE__) + '/../fixtures'
-  CHARSET = "utf-8"
-
-  include ActionMailer::Quoting
-
-  def setup
-    ActionMailer::Base.delivery_method = :test
-    ActionMailer::Base.perform_deliveries = true
-    ActionMailer::Base.deliveries = []
-
-    @expected = TMail::Mail.new
-    @expected.set_content_type "text", "plain", { "charset" => CHARSET }
-  end
-
-  def test_dummy_test
-    #do nothing
-  end
-
-  private
-    def read_fixture(action)
-      IO.readlines("#{FIXTURES_PATH}/<%= file_name %>_mailer/#{action}")
-    end
-
-    def encode(subject)
-      quoted_printable(subject, CHARSET)
-    end
-end

data/lib/generators/somatics/authenticated/templates/test/model_functional_test.rb

@@ -1,93 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require '<%= model_controller_file_name %>_controller'
-
-# Re-raise errors caught by the controller.
-class <%= model_controller_class_name %>Controller; def rescue_action(e) raise e end; end
-
-class <%= model_controller_class_name %>ControllerTest < ActionController::TestCase
-  # Be sure to include AuthenticatedTestHelper in test/test_helper.rb instead
-  # Then, you can remove it from this and the units test.
-  include <%= class_name %>AuthenticatedTestHelper
-
-  fixtures :<%= table_name %>
-
-  def test_should_allow_signup
-    assert_difference '<%= class_name %>.count' do
-      create_<%= file_name %>
-      assert_response :redirect
-    end
-  end
-
-  def test_should_require_login_on_signup
-    assert_no_difference '<%= class_name %>.count' do
-      create_<%= file_name %>(:login => nil)
-      assert assigns(:<%= file_name %>).errors.on(:login)
-      assert_response :success
-    end
-  end
-
-  def test_should_require_password_on_signup
-    assert_no_difference '<%= class_name %>.count' do
-      create_<%= file_name %>(:password => nil)
-      assert assigns(:<%= file_name %>).errors.on(:password)
-      assert_response :success
-    end
-  end
-
-  def test_should_require_password_confirmation_on_signup
-    assert_no_difference '<%= class_name %>.count' do
-      create_<%= file_name %>(:password_confirmation => nil)
-      assert assigns(:<%= file_name %>).errors.on(:password_confirmation)
-      assert_response :success
-    end
-  end
-
-  def test_should_require_email_on_signup
-    assert_no_difference '<%= class_name %>.count' do
-      create_<%= file_name %>(:email => nil)
-      assert assigns(:<%= file_name %>).errors.on(:email)
-      assert_response :success
-    end
-  end
-  <% if options[:stateful] %>
-  def test_should_sign_up_user_in_pending_state
-    create_<%= file_name %>
-    assigns(:<%= file_name %>).reload
-    assert assigns(:<%= file_name %>).pending?
-  end<% end %>
-
-  <% if options[:include_activation] %>
-  def test_should_sign_up_user_with_activation_code
-    create_<%= file_name %>
-    assigns(:<%= file_name %>).reload
-    assert_not_nil assigns(:<%= file_name %>).activation_code
-  end
-
-  def test_should_activate_user
-    assert_nil <%= class_name %>.authenticate('aaron', 'test')
-    get :activate, :activation_code => <%= table_name %>(:aaron).activation_code
-    assert_redirected_to '/<%= controller_routing_path %>/new'
-    assert_not_nil flash[:notice]
-    assert_equal <%= table_name %>(:aaron), <%= class_name %>.authenticate('aaron', 'monkey')
-  end
-  
-  def test_should_not_activate_user_without_key
-    get :activate
-    assert_nil flash[:notice]
-  rescue ActionController::RoutingError
-    # in the event your routes deny this, we'll just bow out gracefully.
-  end
-
-  def test_should_not_activate_user_with_blank_key
-    get :activate, :activation_code => ''
-    assert_nil flash[:notice]
-  rescue ActionController::RoutingError
-    # well played, sir
-  end<% end %>
-
-  protected
-    def create_<%= file_name %>(options = {})
-      post :create, :<%= file_name %> => { :login => 'quire', :email => 'quire@example.com',
-        :password => 'quire69', :password_confirmation => 'quire69' }.merge(options)
-    end
-end

data/lib/generators/somatics/authenticated/templates/test/sessions_functional_test.rb

@@ -1,82 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require '<%= sessions_controller_name %>_controller'
-
-# Re-raise errors caught by the controller.
-class <%= sessions_controller_class_name %>Controller; def rescue_action(e) raise e end; end
-
-class <%= sessions_controller_class_name %>ControllerTest < ActionController::TestCase
-  # Be sure to include AuthenticatedTestHelper in test/test_helper.rb instead
-  # Then, you can remove it from this and the units test.
-  include <%= class_name %>AuthenticatedTestHelper
-
-  fixtures :<%= table_name %>
-
-  def test_should_login_and_redirect
-    post :create, :login => 'quentin', :password => 'monkey'
-    assert session[:<%= file_name %>_id]
-    assert_response :redirect
-  end
-
-  def test_should_fail_login_and_not_redirect
-    post :create, :login => 'quentin', :password => 'bad password'
-    assert_nil session[:<%= file_name %>_id]
-    assert_response :success
-  end
-
-  def test_should_logout
-    login_as :quentin
-    get :destroy
-    assert_nil session[:<%= file_name %>_id]
-    assert_response :redirect
-  end
-
-  def test_should_remember_me
-    @request.cookies["auth_token"] = nil
-    post :create, :login => 'quentin', :password => 'monkey', :remember_me => "1"
-    assert_not_nil @response.cookies["auth_token"]
-  end
-
-  def test_should_not_remember_me
-    @request.cookies["auth_token"] = nil
-    post :create, :login => 'quentin', :password => 'monkey', :remember_me => "0"
-    puts @response.cookies["auth_token"]
-    assert @response.cookies["auth_token"].blank?
-  end
-  
-  def test_should_delete_token_on_logout
-    login_as :quentin
-    get :destroy
-    assert @response.cookies["auth_token"].blank?
-  end
-
-  def test_should_login_with_cookie
-    <%= table_name %>(:quentin).remember_me
-    @request.cookies["auth_token"] = cookie_for(:quentin)
-    get :new
-    assert @controller.send(:logged_in?)
-  end
-
-  def test_should_fail_expired_cookie_login
-    <%= table_name %>(:quentin).remember_me
-    <%= table_name %>(:quentin).update_attribute :remember_token_expires_at, 5.minutes.ago
-    @request.cookies["auth_token"] = cookie_for(:quentin)
-    get :new
-    assert !@controller.send(:logged_in?)
-  end
-
-  def test_should_fail_cookie_login
-    <%= table_name %>(:quentin).remember_me
-    @request.cookies["auth_token"] = auth_token('invalid_auth_token')
-    get :new
-    assert !@controller.send(:logged_in?)
-  end
-
-  protected
-    def auth_token(token)
-      CGI::Cookie.new('name' => 'auth_token', 'value' => token)
-    end
-    
-    def cookie_for(<%= file_name %>)
-      auth_token <%= table_name %>(<%= file_name %>).remember_token
-    end
-end

data/lib/generators/somatics/authenticated/templates/test/unit_test.rb

@@ -1,164 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-class <%= class_name %>Test < ActiveSupport::TestCase
-  # Be sure to include AuthenticatedTestHelper in test/test_helper.rb instead.
-  # Then, you can remove it from this and the functional test.
-  include <%= class_name %>AuthenticatedTestHelper
-  fixtures :<%= table_name %>
-
-  def test_should_create_<%= file_name %>
-    assert_difference '<%= class_name %>.count' do
-      <%= file_name %> = create_<%= file_name %>
-      assert !<%= file_name %>.new_record?, "#{<%= file_name %>.errors.full_messages.to_sentence}"
-    end
-  end
-<% if options[:include_activation] %>
-  def test_should_initialize_activation_code_upon_creation
-    <%= file_name %> = create_<%= file_name %>
-    <%= file_name %>.reload
-    assert_not_nil <%= file_name %>.activation_code
-  end
-<% end %><% if options[:stateful] %>
-  def test_should_create_and_start_in_pending_state
-    <%= file_name %> = create_<%= file_name %>
-    <%= file_name %>.reload
-    assert <%= file_name %>.pending?
-  end
-
-<% end %>
-  def test_should_require_login
-    assert_no_difference '<%= class_name %>.count' do
-      u = create_<%= file_name %>(:login => nil)
-      assert u.errors.on(:login)
-    end
-  end
-
-  def test_should_require_password
-    assert_no_difference '<%= class_name %>.count' do
-      u = create_<%= file_name %>(:password => nil)
-      assert u.errors.on(:password)
-    end
-  end
-
-  def test_should_require_password_confirmation
-    assert_no_difference '<%= class_name %>.count' do
-      u = create_<%= file_name %>(:password_confirmation => nil)
-      assert u.errors.on(:password_confirmation)
-    end
-  end
-
-  def test_should_require_email
-    assert_no_difference '<%= class_name %>.count' do
-      u = create_<%= file_name %>(:email => nil)
-      assert u.errors.on(:email)
-    end
-  end
-
-  def test_should_reset_password
-    <%= table_name %>(:quentin).update_attributes(:password => 'new password', :password_confirmation => 'new password')
-    assert_equal <%= table_name %>(:quentin), <%= class_name %>.authenticate('quentin', 'new password')
-  end
-
-  def test_should_not_rehash_password
-    <%= table_name %>(:quentin).update_attributes(:login => 'quentin2')
-    assert_equal <%= table_name %>(:quentin), <%= class_name %>.authenticate('quentin2', 'monkey')
-  end
-
-  def test_should_authenticate_<%= file_name %>
-    assert_equal <%= table_name %>(:quentin), <%= class_name %>.authenticate('quentin', 'monkey')
-  end
-
-  def test_should_set_remember_token
-    <%= table_name %>(:quentin).remember_me
-    assert_not_nil <%= table_name %>(:quentin).remember_token
-    assert_not_nil <%= table_name %>(:quentin).remember_token_expires_at
-  end
-
-  def test_should_unset_remember_token
-    <%= table_name %>(:quentin).remember_me
-    assert_not_nil <%= table_name %>(:quentin).remember_token
-    <%= table_name %>(:quentin).forget_me
-    assert_nil <%= table_name %>(:quentin).remember_token
-  end
-
-  def test_should_remember_me_for_one_week
-    before = 1.week.from_now.utc
-    <%= table_name %>(:quentin).remember_me_for 1.week
-    after = 1.week.from_now.utc
-    assert_not_nil <%= table_name %>(:quentin).remember_token
-    assert_not_nil <%= table_name %>(:quentin).remember_token_expires_at
-    assert <%= table_name %>(:quentin).remember_token_expires_at.between?(before, after)
-  end
-
-  def test_should_remember_me_until_one_week
-    time = 1.week.from_now.utc
-    <%= table_name %>(:quentin).remember_me_until time
-    assert_not_nil <%= table_name %>(:quentin).remember_token
-    assert_not_nil <%= table_name %>(:quentin).remember_token_expires_at
-    assert_equal <%= table_name %>(:quentin).remember_token_expires_at, time
-  end
-
-  def test_should_remember_me_default_two_weeks
-    before = 2.weeks.from_now.utc
-    <%= table_name %>(:quentin).remember_me
-    after = 2.weeks.from_now.utc
-    assert_not_nil <%= table_name %>(:quentin).remember_token
-    assert_not_nil <%= table_name %>(:quentin).remember_token_expires_at
-    assert <%= table_name %>(:quentin).remember_token_expires_at.between?(before, after)
-  end
-<% if options[:stateful] %>
-  def test_should_register_passive_<%= file_name %>
-    <%= file_name %> = create_<%= file_name %>(:password => nil, :password_confirmation => nil)
-    assert <%= file_name %>.passive?
-    <%= file_name %>.update_attributes(:password => 'new password', :password_confirmation => 'new password')
-    <%= file_name %>.register!
-    assert <%= file_name %>.pending?
-  end
-
-  def test_should_suspend_<%= file_name %>
-    <%= table_name %>(:quentin).suspend!
-    assert <%= table_name %>(:quentin).suspended?
-  end
-
-  def test_suspended_<%= file_name %>_should_not_authenticate
-    <%= table_name %>(:quentin).suspend!
-    assert_not_equal <%= table_name %>(:quentin), <%= class_name %>.authenticate('quentin', 'test')
-  end
-
-  def test_should_unsuspend_<%= file_name %>_to_active_state
-    <%= table_name %>(:quentin).suspend!
-    assert <%= table_name %>(:quentin).suspended?
-    <%= table_name %>(:quentin).unsuspend!
-    assert <%= table_name %>(:quentin).active?
-  end
-
-  def test_should_unsuspend_<%= file_name %>_with_nil_activation_code_and_activated_at_to_passive_state
-    <%= table_name %>(:quentin).suspend!
-    <%= class_name %>.update_all :activation_code => nil, :activated_at => nil
-    assert <%= table_name %>(:quentin).suspended?
-    <%= table_name %>(:quentin).reload.unsuspend!
-    assert <%= table_name %>(:quentin).passive?
-  end
-
-  def test_should_unsuspend_<%= file_name %>_with_activation_code_and_nil_activated_at_to_pending_state
-    <%= table_name %>(:quentin).suspend!
-    <%= class_name %>.update_all :activation_code => 'foo-bar', :activated_at => nil
-    assert <%= table_name %>(:quentin).suspended?
-    <%= table_name %>(:quentin).reload.unsuspend!
-    assert <%= table_name %>(:quentin).pending?
-  end
-
-  def test_should_delete_<%= file_name %>
-    assert_nil <%= table_name %>(:quentin).deleted_at
-    <%= table_name %>(:quentin).delete!
-    assert_not_nil <%= table_name %>(:quentin).deleted_at
-    assert <%= table_name %>(:quentin).deleted?
-  end
-<% end %>
-protected
-  def create_<%= file_name %>(options = {})
-    record = <%= class_name %>.new({ :login => 'quire', :email => 'quire@example.com', :password => 'quire69', :password_confirmation => 'quire69' }.merge(options))
-    record.<% if options[:stateful] %>register! if record.valid?<% else %>save<% end %>
-    record
-  end
-end