backlog 0.37.2 → 0.41.4

data/vendor/plugins/has_history/generators/history_model/history_model_generator.rb

@@ -1,39 +0,0 @@
-class HistoryModelGenerator < Rails::Generator::NamedBase
-  default_options :skip_migration => false
-
-  def manifest
-    record do |m|
-#      # Check for class naming collisions.
-      m.class_collisions class_path, "#{class_name}History"
-#      m.class_collisions class_path, "#{class_name}HistoryTest"
-#
-#      # Model, test, and fixture directories.
-      m.directory File.join('app/models', class_path)
-#      m.directory File.join('test/unit', class_path)
-#      m.directory File.join('test/fixtures', class_path)
-#
-#      # Model class, unit test, and fixtures.
-      m.template 'model.rb',      File.join('app/models', class_path, "#{file_name}_history.rb")
-#      m.template 'unit_test.rb',  File.join('test/unit', class_path, "#{file_name}_history_test.rb")
-#      m.template 'fixtures.yml',  File.join('test/fixtures', class_path, "#{table_name}_history.yml")
-
-      m.dependency 'model', ["#{class_name}History"], :collision => :skip, :skip_migration => true
-
-      unless options[:skip_migration]
-        m.dependency 'history_migration', [class_name], :collision => :skip, :skip_migration => true
-      end
-    end
-  end
-
-  protected
-    def banner
-      "Usage: #{$0} generate ModelName"
-    end
-
-    def add_options!(opt)
-      opt.separator ''
-      opt.separator 'Options:'
-      opt.on("--skip-migration", 
-             "Don't generate a migration file for this history model") { |v| options[:skip_migration] = v }
-    end
-end

data/vendor/plugins/has_history/generators/history_model/templates/fixtures.yml

@@ -1,17 +0,0 @@
-quentin:
-  id: 1
-  login: quentin
-  email: quentin@example.com
-  salt: 7e3041ebc2fc05a40c60028e2c4901a81035d3cd
-  crypted_password: 00742970dc9e6319f8019fd54864d3ea740f04b1 # test
-  #crypted_password: "ce2/iFrNtQ8=\n" # quentin, use only if you're using 2-way encryption
-  created_at: <%%= 5.days.ago.to_s :db %>
-  # activated_at: <%%= 5.days.ago.to_s :db %> # only if you're activating new signups
-aaron:
-  id: 2
-  login: aaron
-  email: aaron@example.com
-  salt: 7e3041ebc2fc05a40c60028e2c4901a81035d3cd
-  crypted_password: 00742970dc9e6319f8019fd54864d3ea740f04b1 # test
-  # activation_code: aaronscode # only if you're activating new signups
-  created_at: <%%= 1.days.ago.to_s :db %>

data/vendor/plugins/has_history/generators/history_model/templates/functional_test.rb

@@ -1,129 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require '<%= controller_file_name %>_controller'
-
-# Re-raise errors caught by the controller.
-class <%= controller_class_name %>Controller; def rescue_action(e) raise e end; end
-
-class <%= controller_class_name %>ControllerTest < Test::Unit::TestCase
-  # Be sure to include AuthenticatedTestHelper in test/test_helper.rb instead
-  # Then, you can remove it from this and the units test.
-  include AuthenticatedTestHelper
-
-  fixtures :<%= table_name %>
-
-  def setup
-    @controller = <%= controller_class_name %>Controller.new
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-  end
-
-  def test_should_login_and_redirect
-    post :login, :login => 'quentin', :password => 'test'
-    assert session[:<%= file_name %>]
-    assert_response :redirect
-  end
-
-  def test_should_fail_login_and_not_redirect
-    post :login, :login => 'quentin', :password => 'bad password'
-    assert_nil session[:<%= file_name %>]
-    assert_response :success
-  end
-
-  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
-
-  def test_should_logout
-    login_as :quentin
-    get :logout
-    assert_nil session[:<%= file_name %>]
-    assert_response :redirect
-  end
-
-  def test_should_remember_me
-    post :login, :login => 'quentin', :password => 'test', :remember_me => "1"
-    assert_not_nil @response.cookies["auth_token"]
-  end
-
-  def test_should_not_remember_me
-    post :login, :login => 'quentin', :password => 'test', :remember_me => "0"
-    assert_nil @response.cookies["auth_token"]
-  end
-  
-  def test_should_delete_token_on_logout
-    login_as :quentin
-    get :logout
-    assert_equal @response.cookies["auth_token"], []
-  end
-
-  def test_should_login_with_cookie
-    <%= table_name %>(:quentin).remember_me
-    @request.cookies["auth_token"] = cookie_for(:quentin)
-    get :index
-    assert @controller.send(:logged_in?)
-  end
-
-  def test_should_fail_expired_cookie_login
-    <%= table_name %>(:quentin).remember_me
-    users(:quentin).update_attribute :remember_token_expires_at, 5.minutes.ago
-    @request.cookies["auth_token"] = cookie_for(:quentin)
-    get :index
-    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 :index
-    assert !@controller.send(:logged_in?)
-  end
-
-  protected
-    def create_<%= file_name %>(options = {})
-      post :signup, :<%= file_name %> => { :login => 'quire', :email => 'quire@example.com', 
-        :password => 'quire', :password_confirmation => 'quire' }.merge(options)
-    end
-    
-    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/vendor/plugins/has_history/generators/history_model/templates/migration.rb

@@ -1,14 +0,0 @@
-class <%= migration_name %> < ActiveRecord::Migration
-  def self.up
-    create_table :<%= table_name %>, :force => true do |t|
-# Remove the columns you don't want recorded.
-<% for column in columns -%>
-      t.column :<%=column.name%>, :<%=column.type%><%=", :limit => #{column.limit}" unless column.limit.nil? %><%=", :null => #{column.null}" unless column.null %><%=", :default => #{column.default}" unless column.default.nil? %>
-<% end -%>
-    end
-  end
-
-  def self.down
-    drop_table "<%= table_name %>"
-  end
-end

data/vendor/plugins/has_history/generators/history_model/templates/model.rb

@@ -1,4 +0,0 @@
-require 'digest/sha1'
-class <%="#{class_name}History" %> < ActiveRecord::Base
-  acts_as_history
-end

data/vendor/plugins/has_history/generators/history_model/templates/unit_test.rb

@@ -1,75 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-class <%= class_name %>Test < Test::Unit::TestCase
-  # Be sure to include AuthenticatedTestHelper in test/test_helper.rb instead.
-  # Then, you can remove it from this and the functional test.
-  include 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
-
-  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', 'test')
-  end
-
-  def test_should_authenticate_<%= file_name %>
-    assert_equal <%= table_name %>(:quentin), <%= class_name %>.authenticate('quentin', 'test')
-  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
-
-  protected
-    def create_<%= file_name %>(options = {})
-      <%= class_name %>.create({ :login => 'quire', :email => 'quire@example.com', :password => 'quire', :password_confirmation => 'quire' }.merge(options))
-    end
-end

data/vendor/plugins/has_history/init.rb

@@ -1,5 +0,0 @@
-require 'has_history'
-
-class ActiveRecord::Base
-  extend HasHistory
-end

data/vendor/plugins/has_history/install.rb

@@ -1 +0,0 @@
-# Install hook code here

data/vendor/plugins/has_history/lib/has_history.rb

@@ -1,178 +0,0 @@
-module HasHistory
-  # TODO (uwe)(2007-10-31): Allow different strategies: timestamped_master, separate_history_table, separate_history_table_with_last
-  
-  # Adds a trigger to the model that saves a copy of the model in a history table.
-  #
-  # The default history model is called <ModelName>History, but can be overridden by the "class_name" option.
-  #
-  # All columns are copied unless excluded by the :except or :only options.
-  #
-  # The created_at field is never changed in the original model, and is therefore omitted in the history model.
-  #
-  # The updated_at column should preserve the original timestamps but changes meaning in the history table.  It therefore is renamed to "valid_from".
-  #
-  # The original row is references by a foreign key column with default name "<lower case model name>_id".
-  # This can be overridden by the :foreign_key option.
-  #
-  # You can automagically generate the history model class at runtime by adding the :generate_model => true option.
-  # In that case, the following option is also available:
-  #
-  # * :allow_updates
-  #
-  # See HasHistory#acts_as_history for a description of this option.
-  #
-  # examples:
-  #
-  #   class Person < ActiveRecord::Base
-  #     has_history
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     has_history :class_name => 'PersonHistory'
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     has_history :except => :birthdate
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     has_history :except => [:birthdate, :social_security_no]
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     has_history :only => :weight
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     has_history :only => [:height, :weight]
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     has_history :foreign_key => :person_id
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     has_history :generate_model => true
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     has_history :generate_model => true, :allow_updates => true
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     has_history :generate_model => true, :allow_updates => true
-  #   end
-  #
-  def has_history options = {}
-    options[:only] = [options[:only]] if options[:only].is_a? Symbol
-    options[:except] = [options[:except]] if options[:except].is_a? Symbol
-    history_model_class_name = (options[:class_name] && options[:class_name].to_s) || "#{name}History"
-    
-    if options[:generate_model]
-      Object::class_eval <<-EOF
-class #{history_model_class_name} < ActiveRecord::Base
-  acts_as_history :class_name => :#{table_name.singularize}, :allow_updates => #{options[:allow_updates].inspect}
-end
-EOF
-    end
-    
-    history_model = history_model_class_name.constantize
-    foreign_key = options[:foreign_key] || "#{table_name.singularize}_id".to_sym
-    
-    before_update do |record|
-      old_values = find(record.id).attributes.symbolize_keys
-      new_values = record.attributes.symbolize_keys
-      values = {foreign_key => record.id}.update(old_values)
-      old_values.delete(:updated_at)
-      new_values.delete(:updated_at)
-      unless new_values == old_values
-        values[:valid_from] = values.delete(:updated_at) if values[:updated_at]
-        values.delete(:id)
-        values.delete_if {|k,v| not history_model.column_names.include? k.to_s}
-        values.delete_if {|k,v| not options[:only].include? k} if options[:only]
-        values.delete_if {|k,v| options[:except].include? k} if options[:except]
-        history_model.create!(values)
-      end
-    end
-    if options[:order] 
-      order = options[:order]
-    elsif history_model.columns.find {|c| c.name == 'valid_from'} 
-      order = 'valid_from DESC'
-    else
-      order = 'id'
-    end
-    has_many history_model.table_name.pluralize.to_sym, :dependent => :destroy, :foreign_key => foreign_key, :order => order
-  end
-  
-  # Adds a belongs_to relationship to a master model and blocks updates and destroy actions on this class.
-  #
-  # If the class name of the history model ends with "History", the default master model class name is automatically calculated (ie. PersonHistory => Person).
-  # If the history class name does not end in "History", or you want to use another class name, you must override it with the :class_name option.
-  #
-  # Normally the history model is blocked for updates, but updates can be enabled by the :allow_updates option.
-  #
-  # The original row is references by a foreign key column with default name "<lower case model name>_id".
-  # This can be overridden by the "foreign_key" option.
-  #
-  # If you would like to inject the update trigger in the master model from the history model, use the :inject_trigger => true option.
-  # If you do this, these additional options are available:
-  #
-  # * :only
-  # * :except
-  #
-  # See HasHistory#has_history for a description of these options.
-  #
-  # examples:
-  #
-  #   class PersonHistory < ActiveRecord::Base
-  #     acts_as_history
-  #   end
-  #
-  #   class PersonRecords < ActiveRecord::Base
-  #     acts_as_history :class_name => 'Person'
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     acts_as_history :allow_updates => true
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     acts_as_history :inject_trigger => true, :except => :birthdate
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     acts_as_history :inject_trigger => true, :except => [:birthdate, :social_security_no]
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     acts_as_history :inject_trigger => true, :only => :weight
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     acts_as_history :inject_trigger => true, :only => [:height, :weight]
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     has_history :foreign_key => :person_id
-  #   end
-  #
-  #   class Person < ActiveRecord::Base
-  #     has_history :generate_model => true
-  #   end
-  #
-  def acts_as_history options = {}
-    model_name = options[:class_name] || (name =~ /(.*)History/ && $1.constantize.table_name.singularize.to_sym)
-    raise "Master model class name '#{$1}' is missing and cannot be deduced." if model_name.nil?
-    belongs_to model_name
-    unless options[:allow_updates]
-      validate_on_update do |record|
-        record.errors.add "History:", "You may not change history!"
-      end
-      before_destroy do |record|
-        record.errors.add :id, "You may not change history!"
-        false
-      end
-    end
-  end
-  
-end