somatics3-generators 0.0.2

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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,164 @@
+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

data/lib/generators/somatics/authenticated/templates/test/users.yml

@@ -0,0 +1,60 @@
+<%
+  ## this code must match that in templates/model.rb
+  require 'digest/sha1'
+  def make_fake_token
+    @fake_token_counter ||= 0
+    @fake_token_counter +=  1
+    Digest::SHA1.hexdigest(@fake_token_counter.to_s)
+  end
+  salts   = (1..2).map{ make_fake_token }
+  passwds = salts.map{ |salt| password_digest('monkey', salt) }
+-%>
+
+quentin:
+  id:                        1
+  login:                     quentin
+  email:                     quentin@example.com
+  salt:                      <%= salts[0]   %> # SHA1('0')
+  crypted_password:          <%= passwds[0] %> # 'monkey'
+  created_at:                <%%= 5.days.ago.to_s :db  %>
+  remember_token_expires_at: <%%= 1.days.from_now.to_s %>
+  remember_token:            <%= make_fake_token %>
+<% if options[:include_activation] -%>
+  activation_code:           
+  activated_at:              <%%= 5.days.ago.to_s :db %>
+<% end -%>
+<% if options[:stateful] -%>
+  state:                     active
+<% end -%>
+      
+aaron:
+  id:                        2
+  login:                     aaron
+  email:                     aaron@example.com
+  salt:                      <%= salts[1]   %> # SHA1('1')
+  crypted_password:          <%= passwds[1] %> # 'monkey'
+  created_at:                <%%= 1.days.ago.to_s :db %>
+  remember_token_expires_at: 
+  remember_token:            
+<% if options[:include_activation] -%>
+  activation_code:           <%= make_fake_token %>
+  activated_at:              
+<% end -%>
+<% if options[:stateful] %>
+  state:                     pending
+<% end -%>
+
+
+old_password_holder:
+  id:                        3
+  login:                     old_password_holder
+  email:                     salty_dog@example.com
+  salt:                      7e3041ebc2fc05a40c60028e2c4901a81035d3cd
+  crypted_password:          00742970dc9e6319f8019fd54864d3ea740f04b1 # test
+  created_at:                <%%= 1.days.ago.to_s :db %>
+<% if options[:include_activation] %>
+  activation_code:           
+  activated_at:              <%%= 5.days.ago.to_s :db %>
+<% end %>
+<% if options[:stateful] %>
+  state:                     active<% end %>

data/lib/generators/somatics/authenticated_controller/authenticated_controller_generator.rb

@@ -0,0 +1,323 @@
+require 'generators/somatics'
+require 'rails/generators/named_base'
+require 'rails/generators/resource_helpers'
+require 'digest/sha1'
+require 'rails/generators/migration'
+        
+module Somatics
+  module Generators
+    class AuthenticatedControllerGenerator < Rails::Generators::NamedBase
+      extend TemplatePath
+      include Rails::Generators::ResourceHelpers
+      include Rails::Generators::Migration
+      # hook_for :authenticated , :in => :somatics, :as => :scaffold, :default => 'somatics:scaffold' do |instance, command|
+      #         instance.invoke command, [ class_name, attributes], {:namespace => 'admin' }
+      # end
+      
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+      class_option :namespace, :banner => "NAME", :type => :string
+      class_option :model, :banner => 'ClasName', :type => :string
+      
+      class_option :skip_routes,          :type => :boolean, :desc => "Don't generate a resource line in config/routes.rb."
+      class_option :skip_migration,       :type => :boolean, :desc => "Don't generate a migration file for this model."
+      class_option :aasm,                 :type => :boolean, :desc => "Works the same as stateful but uses the updated aasm gem"
+      class_option :stateful,             :type => :boolean, :desc => "Builds in support for acts_as_state_machine and generatesactivation code."
+      class_option :rspec,                :type => :boolean, :desc => "Generate RSpec tests and Stories in place of standard rails tests."
+      class_option :old_passwords,        :type => :boolean, :desc => "Use the older password scheme"
+      class_option :include_activation,   :type => :boolean, :desc => "Skip the code for a ActionMailer and its respective Activation Code through email"
+      class_option :dump_generator_attrs, :type => :boolean, :desc => "Dump Generator Attrs"
+      
+      # Try to be idempotent:
+      # pull in the existing site key if any,
+      # seed it with reasonable defaults otherwise
+      #
+      def load_or_initialize_site_keys
+        case
+        when defined? REST_AUTH_SITE_KEY
+          if (options[:old_passwords]) && ((! REST_AUTH_SITE_KEY.blank?) || (REST_AUTH_DIGEST_STRETCHES != 1))
+            raise "You have a site key, but --old-passwords will overwrite it.  If this is really what you want, move the file #{site_keys_file} and re-run."
+          end
+          $rest_auth_site_key_from_generator         = REST_AUTH_SITE_KEY
+          $rest_auth_digest_stretches_from_generator = REST_AUTH_DIGEST_STRETCHES
+        when options[:old_passwords]
+          $rest_auth_site_key_from_generator         = nil
+          $rest_auth_digest_stretches_from_generator = 1
+          $rest_auth_keys_are_new                    = true
+        else
+          $rest_auth_site_key_from_generator         = make_token
+          $rest_auth_digest_stretches_from_generator = 10
+          $rest_auth_keys_are_new                    = true
+        end
+        # template 'config/initializers/site_keys.rb', "config/initializers/#{controller_file_name}_site_keys.rb"
+        template 'config/initializers/site_keys.rb'
+      end
+      
+      def create_controller_files
+        template 'controller.rb', File.join('app/controllers',"#{options.namespace}", controller_class_path, "#{ controller_file_name }_controller.rb")
+      end
+      
+      def generate_lib_files
+        # Check for class naming collisions.
+        class_collisions [], "#{class_name}AuthenticatedSystem", "#{class_name}AuthenticatedTestHelper"
+        
+        template 'authenticated_system.rb', File.join('lib', "#{file_name}_authenticated_system.rb")
+        template 'authenticated_test_helper.rb', File.join('lib', "#{file_name}_authenticated_test_helper.rb")
+      end
+      
+      def create_test_files
+        #TODO : Create test files
+      end
+      
+      def create_helper_files
+        template 'session_helper.rb', File.join('app/helpers', sessions_controller_class_path, "#{ sessions_controller_controller_name }_helper.rb")
+        template 'helper.rb', File.join('app/helpers', controller_class_path, "#{ controller_file_name }_helper.rb")
+      end
+      
+      def generate_sessions_controller
+
+        # Check for class naming collisions.
+        class_collisions sessions_controller_class_path, "#{sessions_controller_class_name}Controller", # Sessions Controller
+                                                         "#{sessions_controller_class_name}Helper"
+
+        template 'sessions_controller.rb', File.join('app/controllers', sessions_controller_class_path, "#{sessions_controller_controller_name}_controller.rb")
+        # template 'session_helper.rb', File.join('app/helpers', sessions_controller_class_path, "#{sessions_controller_controller_name}_helper.rb")
+        # template 'test/sessions_functional_test.rb', File.join('test/functional', sessions_controller_class_path, "#{sessions_controller_file_name}_controller_test.rb")
+
+        # View templates
+        # template 'login.html.erb',  File.join('app/views', sessions_controller_class_path, sessions_controller_file_name, "new.html.erb")
+        template 'login.html.erb', File.join('app/views', sessions_controller_file_path, 'new.html.erb')
+        # template 'signup.html.erb', File.join('app/views', controller_class_path, controller_file_name, "signup.html.erb")
+        template 'signup.html.erb', File.join('app/views', controller_file_path, 'new.html.erb')
+        # template '_model_partial.html.erb', File.join('app/views', controller_class_path, controller_file_name, "_#{file_name}_bar.html.erb")
+        template '_model_partial.html.erb', File.join('app/views', sessions_controller_file_path, "_#{file_name}_bar.html.erb")
+
+      end
+      
+      def generate_route
+        unless options[:skip_routes]
+          route_config =  class_path.collect{|namespace| "namespace :#{namespace} do " }.join(" ")
+          route_config << "\n"
+          route_config << %Q{match '#{file_name}_signup' => '#{controller_plural_name}#new'}
+          route_config << "\n"
+          route_config << %Q{match '#{file_name}_register' => '#{controller_plural_name}#create'}
+          route_config << "\n"
+          route_config << %Q{match '#{file_name}_login' => '#{sessions_controller_controller_name}#new'}
+          route_config << "\n"
+          route_config << %Q{match '#{file_name}_logout' => '#{sessions_controller_controller_name}#destroy'}
+          route_config << "\n"
+          route_config << "match '/activate/:activation_code' => '#{ controller_plural_name }#activate', :as => :activate, :activation_code => nil"
+          route_config << "\n"
+          route_config << "resource #{ sessions_controller_singular_name.to_sym.inspect }, :only => [:new, :create, :destroy]"
+          route_config << "\n"
+          route_config << "resources #{ controller_plural_name.to_sym.inspect }"
+          route_config << "\n"
+          route_config << " end" * class_path.size
+          route route_config
+        end
+      end
+      
+      def insert_into_application_controller
+        puts "TODO: include #{class_name}AuthenticatedSystem"
+        puts "TODO: Add require #{class_name}in AuthenticatedSystem"
+        
+        
+      end
+      
+      def dump_generator_attribute_names
+        generator_attribute_names = [
+          :namespace_class,
+          :namespace_name,          
+          :table_name,
+          :file_name,
+          :class_name,
+          :sessions_controller_name,
+          :sessions_controller_class_path,
+          :sessions_controller_file_path,
+          # :sessions_controller_class_nesting,
+          # :sessions_controller_class_nesting_depth,
+          :sessions_controller_class_name,
+          :sessions_controller_singular_name,
+          :sessions_controller_plural_name,
+          :sessions_controller_routing_name,                 # new_session_path
+          :sessions_controller_routing_path,                 # /session/new
+          :sessions_controller_controller_name,              # sessions
+          :sessions_controller_file_name,
+          :sessions_controller_table_name, 
+          :controller_name,
+          :controller_class_path,
+          :controller_file_path,
+          # :controller_class_nesting,
+          # :controller_class_nesting_depth,
+          :controller_class_name,
+          :controller_singular_name,
+          :controller_plural_name,
+          :controller_routing_name,           # new_user_path
+          :controller_routing_path,           # /users/new
+          :controller_controller_name,        # users
+          :controller_file_name,  
+          :controller_singular_name,
+          :controller_table_name, 
+          :controller_plural_name,
+        ]
+
+        generator_attribute_names.each do |attr|
+          puts "%-40s %s" % ["#{attr}:", self.send(attr.to_s)]  # instance_variable_get("@#{attr.to_s}"
+        end
+
+      end
+      
+      # rails g authenticated FoonParent::Foon SporkParent::Spork -p --force --rspec --dump-generator-attrs
+      # table_name:                              foon_parent_foons
+      # file_name:                               foon
+      # class_name:                              FoonParent::Foon
+      # controller_name:                         SporkParent::Sporks
+      # controller_class_path:                   spork_parent
+      # controller_file_path:                    spork_parent/sporks
+      # controller_class_nesting:                SporkParent
+      # controller_class_nesting_depth:          1
+      # controller_class_name:                   SporkParent::Sporks
+      # controller_singular_name:                spork
+      # controller_plural_name:                  sporks
+      # controller_routing_name:                 spork
+      # controller_routing_path:                 spork_parent/spork
+      # controller_controller_name:              sporks
+      # controller_file_name:                    sporks
+      # controller_table_name:                   sporks
+      # controller_plural_name:                  sporks
+      # model_controller_name:                   FoonParent::Foons
+      # model_controller_class_path:             foon_parent
+      # model_controller_file_path:              foon_parent/foons
+      # model_controller_class_nesting:          FoonParent
+      # model_controller_class_nesting_depth:    1
+      # model_controller_class_name:             FoonParent::Foons
+      # model_controller_singular_name:          foons
+      # model_controller_plural_name:            foons
+      # model_controller_routing_name:           foon_parent_foons
+      # model_controller_routing_path:           foon_parent/foons
+      # model_controller_controller_name:        foons
+      # model_controller_file_name:              foons
+      # model_controller_singular_name:          foons
+      # model_controller_table_name:             foons
+      # model_controller_plural_name:            foons
+      
+      
+      protected 
+      
+      def namespace_class
+        options[:namespace].classify if options[:namespace].present?
+      end
+      
+      def namespace_name
+        options[:namespace].underscore if options[:namespace].present?
+      end
+      
+      def sessions_controller_name
+        file_name + '_sessions'
+      end
+      
+      def sessions_controller_class_path
+        controller_class_path
+      end
+      
+      def sessions_controller_file_path
+        controller_file_path.singularize + '_sessions'
+      end
+      
+      def sessions_controller_singular_name
+        sessions_controller_file_name
+      end
+      
+      def sessions_controller_plural_name
+        sessions_controller_file_name.pluralize
+      end
+      
+      def sessions_controller_routing_name  
+        sessions_controller_routing_path.parameterize.underscore # HACK
+      end      
+      
+      def sessions_controller_routing_path
+        sessions_controller_file_path.singularize
+      end
+      
+      def sessions_controller_class_name
+        controller_class_name.singularize + 'Sessions'
+      end
+      
+      def sessions_controller_controller_name
+        sessions_controller_plural_name
+      end
+      
+      def sessions_controller_file_name
+        file_name + '_session'
+      end
+      
+      def sessions_controller_table_name
+        sessions_controller_plural_name
+      end
+      
+      def controller_plural_name
+        plural_name
+      end
+      
+      def controller_singular_name
+        singular_name
+      end
+      
+      def controller_routing_name
+        controller_routing_path.parameterize.underscore # HACK
+      end
+      
+      def controller_routing_path
+        controller_file_path.singularize
+      end
+      
+      def controller_controller_name
+        controller_plural_name
+      end
+      
+      alias_method  :controller_table_name, :controller_plural_name
+      
+      def model_class_name
+        class_name unless options[:model].present?
+        options[:model].classify
+      end
+      
+      def migration_name
+        "Create#{ class_name.pluralize.gsub(/::/, '') }"
+      end
+
+      def migration_file_name
+        "#{ file_path.gsub(/\//, '_').pluralize }"
+      end
+      
+      #
+      # Implement the required interface for Rails::Generators::Migration.
+      # taken from http://github.com/rails/rails/blob/master/activerecord/lib/generators/active_record.rb
+      #
+      def self.next_migration_number(dirname) #:nodoc:
+        if ActiveRecord::Base.timestamped_migrations
+          Time.now.utc.strftime("%Y%m%d%H%M%S")
+        else
+          "%.3d" % (current_migration_number(dirname) + 1)
+        end
+      end
+      
+      #
+      # !! These must match the corresponding routines in by_password.rb !!
+      #
+      def secure_digest(*args)
+        Digest::SHA1.hexdigest(args.flatten.join('--'))
+      end
+      def make_token
+        secure_digest(Time.now, (1..10).map{ rand.to_s })
+      end
+      def password_digest(password, salt)
+        digest = $rest_auth_site_key_from_generator
+        $rest_auth_digest_stretches_from_generator.times do
+          digest = secure_digest(digest, salt, password, $rest_auth_site_key_from_generator)
+        end
+        digest
+      end
+    end
+  end
+end

data/lib/generators/somatics/authenticated_controller/templates/_model_partial.html.erb

@@ -0,0 +1,8 @@
+<%% if logged_in? -%>
+  <div id="<%= file_name %>-bar-greeting">Logged in as <%%= link_to_current_<%= file_name %> :content_method => :login %></div>
+  <div id="<%= file_name %>-bar-action"  >(<%%= link_to "Log out", logout_path, { :title => "Log out" }    %>)</div>
+<%% else -%>
+  <div id="<%= file_name %>-bar-greeting"><%%= link_to_login_with_IP 'Not logged in', :style => 'border: none;' %></div>
+  <div id="<%= file_name %>-bar-action"  ><%%= link_to "Log in",  login_path,  { :title => "Log in" } %> /
+                               <%%= link_to "Sign up", signup_path, { :title => "Create an account" } %></div>
+<%% end -%>

data/lib/generators/somatics/authenticated_controller/templates/activation.erb

@@ -0,0 +1,3 @@
+<%%=h @<%= file_name %>.login %>, your account has been activated.  Welcome aboard!
+
+  <%%=h @url %>