indexes :accepted_id, :sortable => true

 has :accepted_id, :type => :integer

gem install resque --no-ri --no-rdoc

 Dir["#{Rails.root}/app/jobs/*.rb"].each { |file| require file }

class Job1
  @queue = :job1
  def self.perform(arg)
     p "your code here!!!"
  end
end

rake resque:work QUEUE='*'

DB_ENV = "development"
ROOT = File.expand_path(File.dirname(__FILE__))
database_config = File.expand_path(File.dirname(__FILE__) + "/database.yml")
log_path = File.expand_path(File.dirname(__FILE__) + "/migration.log")

namespace :db do
  task :environment => :load_config do
    ActiveRecord::Base.establish_connection(YAML.load(File.new(database_config))[DB_ENV])
    ActiveRecord::Base.logger = Logger.new(log_path)
  end

  task :load_config do
    require 'active_record'
    ActiveRecord::Base.configurations = YAML.load(File.new(database_config))
  end

  desc '创建数据库'
  task :create => :load_config do
    create_database(ActiveRecord::Base.configurations[DB_ENV])
  end

  desc '删除数据库'
  task :drop => :load_config do
    config = ActiveRecord::Base.configurations[DB_ENV]
    begin
      drop_database(config)
    rescue Exception => e
      puts "Couldn't drop #{config['database']} : #{e.inspect}"
    end
  end

  desc "迁移数据库"
  task :migrate => :environment do
    ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
    ActiveRecord::Migrator.migrate("migrate", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
  end


  desc '重置数据库'
  task :reset => [ 'db:drop', 'db:setup' ]

  desc '重置数据库并且执行seed'
  task :setup => [ 'db:create', 'db:schema:load', 'db:seed' ]

  desc '执行 seed.rb'
  task :seed => :environment do
    seed_file = File.expand_path(File.dirname(__FILE__) + "/seed.rb")
    load(seed_file) if File.exist?(seed_file)
  end

  namespace :schema do
    desc "创建schema.rb"
    task :dump => :environment do
      require 'active_record/schema_dumper'
      File.open(File.expand_path(File.dirname(__FILE__) + "/schema.rb"), "wb") do |file|
        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
      end
      Rake::Task["db:schema:dump"].reenable
    end

    desc "load schema.rb到数据库"
    task :load => :environment do
      file = File.expand_path(File.dirname(__FILE__) + "/schema.rb")
      if File.exists?(file)
        load(file)
      else
        abort %{error}
      end
    end
  end

  namespace :structure do
    desc "导出sql文件"
    task :dump => :environment do
      abcs = ActiveRecord::Base.configurations
      case abcs[DB_ENV]["adapter"]
      when "mysql", "oci", "oracle"
        ActiveRecord::Base.establish_connection(abcs[DB_ENV])
        File.open(ROOT + "/#{DB_ENV}_structure.sql", "wb") do |f|
          f << ActiveRecord::Base.connection.structure_dump
        end
      else
        raise "不支持数据库类型： '#{abcs["test"]["adapter"]}'"
      end

      if ActiveRecord::Base.connection.supports_migrations?
        File.open(ROOT + "/#{DB_ENV}_structure.sql", "a") do |f|
          f << ActiveRecord::Base.connection.dump_schema_information
        end
      end
    end
  end

end

def drop_database(config)
  case config['adapter']
    when 'mysql'
      ActiveRecord::Base.establish_connection(config)
      ActiveRecord::Base.connection.drop_database config['database']
    else
      $stderr.puts "删除数据库出错"
  end
end

def create_database(config)
  case config['adapter']
    when 'mysql'
      @charset   = 'utf8'
      @collation = 'utf8_unicode_ci'
      begin
        ActiveRecord::Base.establish_connection(config.merge('database' => nil))
        ActiveRecord::Base.connection.create_database(config['database'], :charset => (@charset), :collation => (@collation))
        ActiveRecord::Base.establish_connection(config)
      rescue
        $stderr.puts "创建数据库出错"
      end
    else
      $stderr.puts "擦,就支持mysql"
  end
end

class MethodFilter

  def self.before_filter(method)
    puts "add before filter here"
    method = method.to_s
    eval_string = "
      alias_method :old_#{method}, :#{method}

      def #{method}(*args)
        puts 'call'
        old_#{method}(*args)
        puts 'after'
      end
    "
    class_eval(eval_string)
  end
end

class Demo < MethodFilter

  def hello
    puts "hello"
  end

  before_filter(:hello)
end

Demo.new.hello

class WordReplacement < ActiveRecord::Base

  def self.replacement_hash
    Hash[*all.collect{|re| [re.regex_str,re.replacement] }.flatten]
  end

  def self.filter_word_tree(object = nil)
    word_tree = Array.new(256)
    word_tree << 0

    object = replacement_hash if object.nil?

    object.each do |word,replace|
      temp  = word_tree
      bytes = word.bytes.to_a
      len   = bytes.size

      bytes.each_with_index do |asicc_code,arr_index|
        if arr_index < len - 1
          if temp[asicc_code].nil?
            node = [Array.new(256),0]
            temp[asicc_code] = node
          elsif temp[asicc_code] == 1
            node = [Array.new(256),1]
            temp[asicc_code] = node
          else

          end
          temp = temp[asicc_code][0]
        else
          temp[asicc_code] = 1
        end # end if
      end # end bytes
    end # end word
    [word_tree,0]

  end


  def self.handle_word(do_words,replace = true,word_tree = nil,word_hash = nil)
    word_tree = filter_word_tree if word_tree.nil?
    word_hash = replacement_hash if word_hash.nil?
    temp      = word_tree
    nodeTree  = word_tree
    words     = []
    word      = []
    to_replace= []
    a         = 0
    while a < do_words.size
      index = do_words[a]
      temp = temp[0][index]
      if temp.nil?
        temp = nodeTree
        a = a - word.size
        word = []
        to_replace = []
      elsif temp == 1 or temp[1] == 1
        word << index
        to_replace << a
        words << word
       
        if replace
          replace_word = word_hash[asicc_code_to_s(word)]
          do_words[(a-to_replace.size + 1),to_replace.size] = replace_word
          a = (a - to_replace.size + 1) + (replace_word.size - 1)
        else
          a = a - word.size + 1
        end
        word = []
        to_replace = []
        temp = nodeTree
      else
        word << index
        to_replace << a
      end
      a += 1  
    end
    return do_words if replace
    words.collect{|e| e.collect{|ch|ch.chr}.join }
  end

  protected
  def self.asicc_code_to_s(words)
    words.collect{|e| e.chr }.join
  end

end

require 'observer'
class User
  include Observable
  attr_accessor :username
  attr_accessor :password
 
  def initialize(username,password)
      @username = username
      @password = password
  end
 
  def change_username
        changed
        @username = "find_by_username"
        notify_observers
  end

end

class Foo
    def update()
        p "attribute has update"
    end    
end
#试着改变username属性
  user = User.new("neo","123")
  user.add_observer(Foo.new)
  user.change_username

require 'jcode'
class String
  def size
    self.jsize
  end
end

class NeoDiff
  $KCODE = "u"
  attr_accessor :output
  attr_accessor :last_call
 
  def initialize(output)
    @output = output
    @last_call = nil
  end
 
  def change(event)
    if @last_call.nil?
      @output << "<span class='change'>#{event.old_element}"
    elsif @last_call == "change"
      @output << event.old_element
    else
      @output << "</span><span class='change'>#{event.old_element}"
    end
    @last_call = "change"
  end

  def match(event)
    if @last_call.nil?
      @output << "<span class='match'>#{event.old_element}"
    elsif @last_call == "match"
      @output << event.old_element
    else
      @output << "</span><span class='match'>#{event.old_element}"
    end
    @last_call = "match"
  end


  def discard_a(event)
    if @last_call.nil?
      @output << "<span class='only_a'>#{event.old_element}"
    elsif @last_call == "discard_a"
      @output << event.old_element
    else
      @output << "</span><span class='only_a'>#{event.old_element}"
    end
    @last_call = "discard_a"
  end

  def discard_b(event)
    if @last_call.nil?
      @output << "<span class='only_b'>#{event.new_element}"
    elsif @last_call == "discard_b"
      @output << event.new_element
    else
      @output << "</span><span class='only_b'>#{event.new_element}"
    end
    @last_call = "discard_b"
  end
end