module DataMapper
  module Validate
 
    class ValidationErrors
      def to_json
        @errors.to_hash.to_json
      end
    end
  end
end

class People < Merb::Controller
 
  def create(person)
    #... *SNIP* ...
    display @person, nil, {:methods => [:errors]}
    #... *SNIP* ...
  end
end

# First you need aws rubygem.
gem install aws-s3
export AS3_ACCESS_KEY=YOUR_KEY_HERE
export AS3_SECRET_KEY=YOUR_SECRET_HERE

require 'rubygems'
require 'aws/s3'
 
AWS::S3::Base.establish_connection!(
  :access_key_id     => ENV['AS3_ACCESS_KEY'],
  :secret_access_key => ENV['AS3_SECRET_KEY']
)
 
def git_archive(revision='HEAD', filename = nil, format='tar')
  filename ||= revision
 
  if format == 'tar'
    filename = "#{filename}.tar.gz"
  else
    filename = "#{filename}.zip"
  end
 
  `git archive --format=#{format} #{revision} | gzip > #{filename}`
  if $? == 0
    filename 
  else
    return false
  end
end
 
def s3put(filename, opts={})
  deploy_label = filename
  backup_label = "#{$REVISION}-#{filename}"
 
  file_ref = File.read File.expand_path(filename)
 
  # Push the package twice, once with the revision in the name, and once as the intended package
  #   acts as a sort of back up of what has been pushed...
  [deploy_label, backup_label].each do |file_label|
    begin
      puts "Putting to S3: #{file_label}"
 
      AWS::S3::S3Object.store(
        file_label,
        file_ref,
        $BUCKET_NAME,
        :content_type => (file_label =~ /\.tar\.gz$/i ? 'application/x-gzip' : 'application/x-zip'),
        :access       => :private
      )
    rescue Exception => ex
      puts ex.message
      return false
    end
  end
 
  return true
end
 
 
def s3get(filename)
  local_filename = File.expand_path(filename)
 
  File.open(local_filename, 'w') do |new_file|
    AWS::S3::S3Object.stream(filename,$BUCKET_NAME) do |chunk|
      new_file.write chunk
    end
  end
 
  return File.exist?(filename)
end
 
if ARGV.index('-h') || ARGV.empty?
  puts "============================================================================"
  puts "Packages a git revision w/o git data to Amazon S3"
  puts "package.rb --bucket [BUCKET_NAME] --revision [REVISION|HEAD] --FILENAME [production|experimental|USER_DEF]"
  puts "To see revisions do 'git log'"
  puts "============================================================================"
  exit(0)
end
 
$REVISION = ARGV[ARGV.index('--revision') + 1] rescue nil
$OUT_NAME = ARGV[ARGV.index('--filename') + 1] rescue nil
$BUCKET_NAME   = ARGV[ARGV.index('--bucket') + 1] rescue nil
 
begin
  AWS::S3::Bucket.find $BUCKET_NAME
rescue Exception => ex
  puts "Could not fetch bucket #{$BUCKET_NAME}, did you set $AS3_ACCESS_KEY & $AS3_SECRET_KEY?"
  exit(1)  
end
 
if $REVISION.nil?
  puts "--revision is required"
  exit 3
end
 
arch_file = git_archive($REVISION, $OUT_NAME)
 
if arch_file && s3put(arch_file)
  puts "SUCCESS"
else
  puts "FAILED"
end
# First

chmod +x s3packager.rb

s3packager.rb --revision YOUR_GIT_LOG_REVISION_ID --bucket YOUR_AMAZON_BUCKET --filename THE_NAME_OF_THE_FILE_YOUR_SERVER_IS_LOOKING_FOR

s3packager.rb -h

class String
  def nysiis
    str = self.upcase
    str.strip!      
    str.gsub!(/[^A-Z ]/,"")
    str.gsub!(/ +(JR|SR)$/,"")
    str.gsub!(/ +(I|V|X|L|C|D|M)+$/,"")
    str.gsub!(/ /,"")
 
    # 1. Translate first characters of name: 
    # => MAC → MCC, KN → NN, K → C, PH → FF, PF → FF, SCH → SSS        
    {
      /^MAC/      => "MCC",
      /^KN/       => "NN",
      /^K/        => "C",
      /^(PH|PF)/  => "FF",
      /SCH/       => "SSS"
    }.each do |r,s|
      break if str.sub!(r,s)
    end
 
    # 2. Translate last characters of name: 
    # => EE → Y, IE → Y, DT, RT, RD, NT, ND → D
    str.sub!(/(EE|IE)$/,"Y")
    str.sub!(/(DT|RT|RD|NT|ND)$/,"D")
 
    # 3. First character of key = first character of name.
    first_char = str[0,1]
    str = str[1,str.length]
 
    # 4. Translate remaining characters by following rules, 
    #    incrementing by one character each time:
    # => EV → AF else A, E, I, O, U → A
    # => Q → G, Z → S, M → N
    # => KN → NN else K → C
    # => SCH → SSS, PH → FF
    # => H → If previous or next is nonvowel, previous.
    # => W → If previous is vowel, previous. (A is the only vowel left)    
    str.gsub!(/EV/, "AF")
    str.gsub!(/[AEIOU]/,"A")
    str.gsub!(/Q/, "G")
    str.gsub!(/Z/, "S")
    str.gsub!(/M/, "N")
    str.gsub!(/KN/, "NN")
    str.gsub!(/K/, "C")
    str.gsub!(/SCH/, "SSS")
    str.gsub!(/PH/, "FF")
    str.gsub!(/([^AEIOU])H/, $1) if $1
    str.gsub!(/(.)H[^AEIOU]/, $1) if $1
    str.gsub!(/AW/, "A")
 
    # 4. CONTINUED
    # => Add current to key if current is not same as the last key character.
    str.squeeze!     #everything was done in place, so squeeze out the duplicates
    str = first_char + str
 
    # 5. If last character is S, remove it.
    # 6. If last characters are AY, replace with Y.
    # 7. If last character is A, remove it.
    str.sub!(/(S|A)$/,"")
    str.sub!(/AY$/,"Y")
 
    return str
  end
 
end

# include file from above
"Cory".nysiis #=> "CARY"
"O'Daniel".nysiis #=> "ODANAL"

class String
  def distance(other_str)
    _self_str = self.downcase
    _othr_str = other_str.downcase
 
    # Shortcuts
    return 0 if _self_str == _othr_str    
    return _self_str.length if (0 == _othr_str.length)
    return _othr_str.length if (0 == _self_str.length)
 
    # how to unpack
    unpack_rule = ($KCODE =~ /^U/i) ? 'U*' : 'C*'
 
    #longer, shorter
    _str_1, _str_2 = if _self_str.length > _othr_str.length
      [_self_str, _othr_str]
    else
      [_othr_str, _self_str]
    end
 
    # get different in length as base
    difference_counter = _str_1.length - _str_2.length
 
    # Shorten first string & unpack
    _str_1 = _str_1[0, _str_2.length].unpack(unpack_rule)
    _str_2 = _str_2.unpack(unpack_rule)
 
    _str_1.each_with_index do |char1, idx|
      char2 = _str_2[idx]
      difference_counter += 1 if char1 != char2
    end
 
    return difference_counter
  end
end

#include the file from above
"kitten".distance("sitting") #=> 3

require 'benchmark'
 
 
class String
  def distance(other_str)
    _self_str = self.downcase
    _othr_str = other_str.downcase
 
    # Shortcuts
    return 0 if _self_str == _othr_str    
    return _self_str.length if (0 == _othr_str.length)
    return _othr_str.length if (0 == _self_str.length)
 
    # how to unpack
    unpack_rule = ($KCODE =~ /^U/i) ? 'U*' : 'C*'
 
    #longer, shorter
    _str_1, _str_2 = if _self_str.length > _othr_str.length
      [_self_str, _othr_str]
    else
      [_othr_str, _self_str]
    end
 
    # get different in length as base
    difference_counter = _str_1.length - _str_2.length
 
    # Shorten first string & unpack
    _str_1 = _str_1[0, _str_2.length].unpack(unpack_rule)
    _str_2 = _str_2.unpack(unpack_rule)
 
    _str_1.each_with_index do |char1, idx|
      char2 = _str_2[idx]
      difference_counter += 1 if char1 != char2
    end
 
    return difference_counter
  end
end
 
def levenshtein(a,b)
  case
    when a.empty?: b.length
    when b.empty?: a.length
    else [(a[0] == b[0] ? 0 : 1) + levenshtein(a[1..-1], b[1..-1]),
          1 + levenshtein(a[1..-1], b),
          1 + levenshtein(a, b[1..-1])].min
  end
end
 
 
n = 50000
Benchmark.bm do |x|
  x.report("Levenshtein Distance (Cory, Small Difference)"){ 
    "kitten".distance("smitten")
  }
  x.report("Levenshtein Distance (Wikibooks, Small Difference)") { 
    levenshtein("kitten", "smitten")
  }
 
  x.report("Levenshtein Distance (Cory, Large Difference)"){ 
    "constantinople".distance("antelope")
  }
  x.report("Levenshtein Distance (Wikibooks, Large Difference)") { 
    levenshtein(    "constantinople","antelope")
  }
end