amrita2 1.9.6 → 2.0.0

data/sample/login_engine/app/models/user_notify.rb

@@ -0,0 +1,75 @@
+class UserNotify < ActionMailer::Base
+  def signup(user, password, url=nil)
+    setup_email(user)
+
+    # Email header info
+    @subject += "Welcome to #{LoginEngine.config(:app_name)}!"
+
+    # Email body substitutions
+    @body["name"] = "#{user.firstname} #{user.lastname}"
+    @body["login"] = user.login
+    @body["password"] = password
+    @body["url"] = url || LoginEngine.config(:app_url).to_s
+    @body["app_name"] = LoginEngine.config(:app_name).to_s
+  end
+
+  def forgot_password(user, url=nil)
+    setup_email(user)
+
+    # Email header info
+    @subject += "Forgotten password notification"
+
+    # Email body substitutions
+    @body["name"] = "#{user.firstname} #{user.lastname}"
+    @body["login"] = user.login
+    @body["url"] = url || LoginEngine.config(:app_url).to_s
+    @body["app_name"] = LoginEngine.config(:app_name).to_s
+  end
+
+  def change_password(user, password, url=nil)
+    setup_email(user)
+
+    # Email header info
+    @subject += "Changed password notification"
+
+    # Email body substitutions
+    @body["name"] = "#{user.firstname} #{user.lastname}"
+    @body["login"] = user.login
+    @body["password"] = password
+    @body["url"] = url || LoginEngine.config(:app_url).to_s
+    @body["app_name"] = LoginEngine.config(:app_name).to_s
+  end
+
+  def pending_delete(user, url=nil)
+    setup_email(user)
+
+    # Email header info
+    @subject += "Delete user notification"
+
+    # Email body substitutions
+    @body["name"] = "#{user.firstname} #{user.lastname}"
+    @body["url"] = url || LoginEngine.config(:app_url).to_s
+    @body["app_name"] = LoginEngine.config(:app_name).to_s
+    @body["days"] = LoginEngine.config(:delayed_delete_days).to_s
+  end
+
+  def delete(user, url=nil)
+    setup_email(user)
+
+    # Email header info
+    @subject += "Delete user notification"
+
+    # Email body substitutions
+    @body["name"] = "#{user.firstname} #{user.lastname}"
+    @body["url"] = url || LoginEngine.config(:app_url).to_s
+    @body["app_name"] = LoginEngine.config(:app_name).to_s
+  end
+
+  def setup_email(user)
+    @recipients = "#{user.email}"
+    @from       = LoginEngine.config(:email_from).to_s
+    @subject    = "[#{LoginEngine.config(:app_name)}] "
+    @sent_on    = Time.now
+    @headers['Content-Type'] = "text/plain; charset=#{LoginEngine.config(:mail_charset)}; format=flowed"
+  end
+end

data/sample/login_engine/config/boot.rb

@@ -0,0 +1,45 @@
+# Don't change this file. Configuration is done in config/environment.rb and config/environments/*.rb
+
+unless defined?(RAILS_ROOT)
+  root_path = File.join(File.dirname(__FILE__), '..')
+
+  unless RUBY_PLATFORM =~ /(:?mswin|mingw)/
+    require 'pathname'
+    root_path = Pathname.new(root_path).cleanpath(true).to_s
+  end
+
+  RAILS_ROOT = root_path
+end
+
+unless defined?(Rails::Initializer)
+  if File.directory?("#{RAILS_ROOT}/vendor/rails")
+    require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer"
+  else
+    require 'rubygems'
+
+    environment_without_comments = IO.readlines(File.dirname(__FILE__) + '/environment.rb').reject { |l| l =~ /^#/ }.join
+    environment_without_comments =~ /[^#]RAILS_GEM_VERSION = '([\d.]+)'/
+    rails_gem_version = $1
+
+    if version = defined?(RAILS_GEM_VERSION) ? RAILS_GEM_VERSION : rails_gem_version
+      # Asking for 1.1.6 will give you 1.1.6.5206, if available -- makes it easier to use beta gems
+      rails_gem = Gem.cache.search('rails', "~>#{version}.0").sort_by { |g| g.version.version }.last
+
+      if rails_gem
+        gem "rails", "=#{rails_gem.version.version}"
+        require rails_gem.full_gem_path + '/lib/initializer'
+      else
+        STDERR.puts %(Cannot find gem for Rails ~>#{version}.0:
+    Install the missing gem with 'gem install -v=#{version} rails', or
+    change environment.rb to define RAILS_GEM_VERSION with your desired version.
+  )
+        exit 1
+      end
+    else
+      gem "rails"
+      require 'initializer'
+    end
+  end
+
+  Rails::Initializer.run(:set_load_path)
+end

data/sample/login_engine/config/environment.rb

@@ -0,0 +1,140 @@
+
+$KCODE = 'u'            # UTF-8�ξ�硣's' = SJIS, 'e' = EUC-JP�ʤ�
+require 'jcode'         # String���饹�Υ᥽�åɤʤɤ�$KCODE�˻��ꤷ��
+                        # ʸ�������ɤ�Ŭ�ڤ�ư���褦���֤������ޤ���
+
+
+# Be sure to restart your web server when you modify this file.
+
+# Uncomment below to force Rails into production mode when
+# you don't control web/app server and can't set it the proper way
+# ENV['RAILS_ENV'] ||= 'production'
+
+# Specifies gem version of Rails to use when vendor/rails is not present
+#RAILS_GEM_VERSION = '1.1.6' unless defined? RAILS_GEM_VERSION
+
+# Bootstrap the Rails environment, frameworks, and default configuration
+require File.join(File.dirname(__FILE__), 'boot')
+
+Rails::Initializer.run do |config|
+  # Settings in config/environments/* take precedence over those specified here
+
+  # Skip frameworks you're not going to use (only works if using vendor/rails)
+  # config.frameworks -= [ :action_web_service, :action_mailer ]
+
+  # Only load the plugins named here, by default all plugins in vendor/plugins are loaded
+  # config.plugins = %W( exception_notification ssl_requirement )
+
+  # Add additional load paths for your own custom dirs
+  # config.load_paths += %W( #{RAILS_ROOT}/extras )
+
+  # Force all environments to use the same logger level
+  # (by default production uses :info, the others :debug)
+  # config.log_level = :debug
+
+  # Use the database for sessions instead of the file system
+  # (create the session table with 'rake db:sessions:create')
+  # config.action_controller.session_store = :active_record_store
+
+  # Use SQL instead of Active Record's schema dumper when creating the test database.
+  # This is necessary if your schema can't be completely dumped by the schema dumper,
+  # like if you have constraints or database-specific column types
+  # config.active_record.schema_format = :sql
+
+  # Activate observers that should always be running
+  # config.active_record.observers = :cacher, :garbage_collector
+
+  # Make Active Record use UTC-base instead of local time
+  # config.active_record.default_timezone = :utc
+
+  # See Rails::Configuration for more options
+end
+
+# Add new inflection rules using the following format
+# (all these examples are active by default):
+# Inflector.inflections do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end
+
+# Add new mime types for use in respond_to blocks:
+# Mime::Type.register "text/richtext", :rtf
+# Mime::Type.register "application/x-mobile", :mobile
+
+# Include your application configuration below
+
+require 'config'
+
+module LoginEngine
+ include AuthenticatedSystem # re-include the helper module
+
+  #--
+  # Define the configuration values. config sets the value of the
+  # constant ONLY if it has not already been set, i.e. by the user in
+  # environment.rb
+  #++
+
+  # Source address for user emails
+  config :email_from, 'webmaster@your.company'
+
+  # Destination email for system errors
+  config :admin_email, 'webmaster@your.company'
+
+  # Sent in emails to users
+  config :app_url, 'http://localhost:3000/'
+
+  # Sent in emails to users
+  config :app_name, 'TestApp'
+
+  # Email charset
+  config :mail_charset, 'utf-8'
+
+  # Security token lifetime in hours
+  config :security_token_life_hours, 24
+
+  # Two column form input
+  config :two_column_input, true
+
+  # Add all changeable user fields to this array.
+  # They will then be able to be edited from the edit action. You
+  # should NOT include the email field in this array.
+  config :changeable_fields, [ 'firstname', 'lastname' ]
+
+  # Set to true to allow delayed deletes (i.e., delete of record
+  # doesn't happen immediately after user selects delete account,
+  # but rather after some expiration of time to allow this action
+  # to be reverted).
+  config :delayed_delete, false
+
+  # Default is one week
+  config :delayed_delete_days, 7
+
+  # the table to store user information in
+  if ActiveRecord::Base.pluralize_table_names
+    config :user_table, "users"
+  else
+    config :user_table, "user"
+  end
+
+  # controls whether or not email is used
+  config :use_email_notification, true
+
+  # Controls whether accounts must be confirmed after signing up
+  # ONLY if this and use_email_notification are both true
+  config :confirm_account, true
+
+
+  config :salt, "your-salt-here"
+end
+
+
+require 'gettext'
+require 'gettext/rails'
+require 'amrita2/gettext'
+require 'amrita2/macro'
+
+# set text domain for get_text
+Amrita2View::Base.text_domain = "login_engine"
+

data/sample/login_engine/config/environments/development.rb

@@ -0,0 +1,21 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# In the development environment your application's code is reloaded on
+# every request.  This slows down response time but is perfect for development
+# since you don't have to restart the webserver when you make code changes.
+config.cache_classes = false
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Enable the breakpoint server that script/breakpointer connects to
+config.breakpoint_server = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+config.action_view.cache_template_extensions         = false
+config.action_view.debug_rjs                         = true
+
+# Don't care if the mailer can't send
+config.action_mailer.raise_delivery_errors = false

data/sample/login_engine/config/environments/production.rb

@@ -0,0 +1,18 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# The production environment is meant for finished, "live" apps.
+# Code is not reloaded between requests
+config.cache_classes = true
+
+# Use a different logger for distributed setups
+# config.logger = SyslogLogger.new
+
+# Full error reports are disabled and caching is turned on
+config.action_controller.consider_all_requests_local = false
+config.action_controller.perform_caching             = true
+
+# Enable serving of images, stylesheets, and javascripts from an asset server
+# config.action_controller.asset_host                  = "http://assets.example.com"
+
+# Disable delivery errors, bad email addresses will be ignored
+# config.action_mailer.raise_delivery_errors = false

data/sample/login_engine/config/environments/test.rb

@@ -0,0 +1,19 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# The test environment is used exclusively to run your application's
+# test suite.  You never need to work with it otherwise.  Remember that
+# your test database is "scratch space" for the test suite and is wiped
+# and recreated between test runs.  Don't rely on the data there!
+config.cache_classes = true
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+
+# Tell ActionMailer not to deliver emails to the real world.
+# The :test delivery method accumulates sent emails in the
+# ActionMailer::Base.deliveries array.
+config.action_mailer.delivery_method = :test

data/sample/login_engine/config/routes.rb

@@ -0,0 +1,23 @@
+ActionController::Routing::Routes.draw do |map|
+  # The priority is based upon order of creation: first created -> highest priority.
+  
+  # Sample of regular route:
+  # map.connect 'products/:id', :controller => 'catalog', :action => 'view'
+  # Keep in mind you can assign values other than :controller and :action
+
+  # Sample of named route:
+  # map.purchase 'products/:id/purchase', :controller => 'catalog', :action => 'purchase'
+  # This route can be invoked with purchase_url(:id => product.id)
+
+  # You can have the root of your site routed by hooking up '' 
+  # -- just remember to delete public/index.html.
+  # map.connect '', :controller => "welcome"
+
+  # Allow downloading Web Service WSDL as a file with an extension
+  # instead of a file named 'wsdl'
+  map.connect ':controller/service.wsdl', :action => 'wsdl'
+
+  # Install the default route as the lowest priority.
+  map.connect ':controller/:action/:id.:format'
+  map.connect ':controller/:action/:id'
+end

data/sample/login_engine/db/migrate/001_create_users.rb

@@ -0,0 +1,25 @@
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.column "login", :string, :limit => 80, :default => "", :null => false
+      t.column "salted_password", :string, :limit => 40, :default => "", :null => false
+      t.column "email", :string, :limit => 60, :default => "", :null => false
+      t.column "firstname", :string, :limit => 40
+      t.column "lastname", :string, :limit => 40
+      t.column "salt", :string, :limit => 40, :default => "", :null => false
+      t.column "verified", :integer, :default => 0
+      t.column "role", :string, :limit => 40
+      t.column "security_token", :string, :limit => 40
+      t.column "token_expiry", :datetime
+      t.column "created_at", :datetime
+      t.column "updated_at", :datetime
+      t.column "logged_in_at", :datetime
+      t.column "deleted", :integer, :default => 0
+      t.column "delete_after", :datetime
+    end
+  end
+
+  def self.down
+    drop_table :users
+  end
+end

data/sample/login_engine/db/schema.rb

@@ -0,0 +1,25 @@
+# This file is autogenerated. Instead of editing this file, please use the
+# migrations feature of ActiveRecord to incrementally modify your database, and
+# then regenerate this schema definition.
+
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table "users", :force => true do |t|
+    t.column "login",           :string,   :limit => 80, :default => "", :null => false
+    t.column "salted_password", :string,   :limit => 40, :default => "", :null => false
+    t.column "email",           :string,   :limit => 60, :default => "", :null => false
+    t.column "firstname",       :string,   :limit => 40
+    t.column "lastname",        :string,   :limit => 40
+    t.column "salt",            :string,   :limit => 40, :default => "", :null => false
+    t.column "verified",        :integer,                :default => 0
+    t.column "role",            :string,   :limit => 40
+    t.column "security_token",  :string,   :limit => 40
+    t.column "token_expiry",    :datetime
+    t.column "created_at",      :datetime
+    t.column "updated_at",      :datetime
+    t.column "logged_in_at",    :datetime
+    t.column "deleted",         :integer,                :default => 0
+    t.column "delete_after",    :datetime
+  end
+
+end

data/sample/login_engine/lib/config.rb

@@ -0,0 +1,113 @@
+#--
+# Add these methods to the top-level module so that they are available in all
+# modules, etc
+#++
+class ::Module
+  # Defines a constant within a module/class ONLY if that constant does
+  # not already exist.
+  #
+  # This can be used to implement defaults in plugins/engines/libraries, e.g.
+  # if a plugin module exists:
+  #   module MyPlugin
+  #     default_constant :MyDefault, "the_default_value"
+  #   end
+  #
+  # then developers can override this default by defining that constant at
+  # some point *before* the module/plugin gets loaded (such as environment.rb)
+  def default_constant(name, value)
+    if !(name.is_a?(String) or name.is_a?(Symbol))
+      raise "Cannot use a #{name.class.name} ['#{name}'] object as a constant name"
+    end
+    if !self.const_defined?(name)
+      self.class_eval("#{name} = #{value.inspect}")
+    end
+  end
+  
+  # A mechanism for defining configuration of Modules. With this
+  # mechanism, default values for configuration can be provided within shareable
+  # code, and the end user can customise the configuration without having to
+  # provide all values.
+  #
+  # Example:
+  #
+  #  module MyModule
+  #    config :param_one, "some value"
+  #    config :param_two, 12345
+  #  end
+  #
+  # Those values can now be accessed by the following method
+  #
+  #   MyModule.config :param_one  
+  #     => "some value"
+  #   MyModule.config :param_two  
+  #     => 12345
+  #
+  # ... or, if you have overrriden the method 'config'
+  #
+  #   MyModule::CONFIG[:param_one]  
+  #     => "some value"
+  #   MyModule::CONFIG[:param_two]  
+  #     => 12345
+  #
+  # Once a value is stored in the configuration, it will not be altered
+  # by subsequent assignments, unless a special flag is given:
+  #
+  #   (later on in your code, most likely in another file)
+  #   module MyModule
+  #     config :param_one, "another value"
+  #     config :param_two, 98765, :force
+  #   end
+  #
+  # The configuration is now:
+  #
+  #   MyModule.config :param_one  
+  #     => "some value" # not changed
+  #   MyModule.config :param_two  
+  #     => 98765
+  #
+  # Configuration values can also be given as a Hash:
+  #
+  #   MyModule.config :param1 => 'value1', :param2 => 'value2'
+  #
+  # Setting of these values can also be forced:
+  #
+  #   MyModule.config :param1 => 'value3', :param2 => 'value4', :force => true
+  #
+  # A value of anything other than false or nil given for the :force key will
+  # result in the new values *always* being set.
+  def config(*args)
+    
+    raise "config expects at least one argument" if args.empty?
+    
+    # extract the arguments
+    if args[0].is_a?(Hash)
+      override = args[0][:force]
+      args[0].delete(:force)
+      args[0].each { |key, value| _handle_config(key, value, override)}
+    else
+      _handle_config(*args)
+    end
+  end
+  
+  private
+    # Actually set the config values
+    def _handle_config(name, value=nil, override=false)
+      if !self.const_defined?("CONFIG")
+        self.class_eval("CONFIG = {}")
+      end
+    
+      if value != nil
+        if override or self::CONFIG[name] == nil
+          self::CONFIG[name] = value 
+        end
+      else
+        # if we pass an array of config keys to config(),
+        # get the array of values back
+        if name.is_a? Array
+          name.map { |c| self::CONFIG[c] }
+        else
+          self::CONFIG[name]
+        end
+      end      
+    end
+end

data/sample/login_engine/lib/hpricot_test_extension.rb

@@ -0,0 +1,80 @@
+require 'hpricot'
+
+module HpricotTestExtension
+  # returns the inner content of
+  # the first tag found by the css query
+  def tag(css_query)
+    process_output
+    @output.content_for(css_query)
+  end
+  
+  # returns an array of tag contents
+  # for all of the tags found by the
+  # css query
+  def tags(css_query)
+    process_output
+    @output.content_for_all(css_query)
+  end
+  
+  # returns a raw Hpricot::Elem object
+  # for the first result found by the query
+  def element(css_query)
+    process_output
+    @output[css_query].first
+  end
+  
+  # returns an array of Hpricot::Elem objects
+  # for the results found by the query
+  def elements(css_query)
+    process_output
+    @output[css_query]
+  end
+  
+  # small utility class for working with
+  # the Hpricot parser class
+  class DocumentOutput
+    def initialize(response_body)
+      @parser = Hpricot.parse(response_body)
+    end
+
+    def content_for(css_query)
+      @parser.search(css_query).first.inner_text
+    end
+
+    def content_for_all(css_query)
+      @parser.search(css_query).collect(&:inner_text)
+    end
+
+    def [](css_query)
+      @parser.search(css_query)
+    end
+  end
+  
+  protected
+    # creates a new DocumentOutput object from the response
+    # body if hasn't already been created. This is
+    # called automatically by the element and tag methods
+    def process_output      
+      @output = HpricotTestExtension::DocumentOutput.new(@response.body) if @output.nil?  
+    end
+end
+
+# monkey patches
+class Hpricot::Elem
+  def should_contain(value)
+    self.inner_text.include?(value)
+  end
+  
+  # courtesy of 'thomas' from the comments
+  # of _whys blog - get in touch if you want a better credit!
+  def inner_text
+    self.children.collect do |child|
+      child.is_a?(Hpricot::Text) ? child.content : child.inner_text
+    end.join.strip
+  end
+end
+
+# inject into test::unit
+class Test::Unit::TestCase
+  include HpricotTestExtension
+end