xiajian (夏健)

分享如何创建一个新 Ruby Gem

xiajian — Thu, 24 Nov 2016 19:43:12 +0800

原发于： http://bbs.yundianjia.net/d/111-2-ruby-gem

写的不好，希望大家吐槽拉。这里贴出的代码，是最初一个版本的，后续的修改，可以参考 https://github.com/xiajian/bbs_uploader，代码没写测试。确实是个硬伤。更多关于 gem 编写的介绍： http://guides.rubygems.org/make-your-own-gem/

如何创建一个 gem，并将其发布到 rubygems 上，让世界感受你的代码中蕴含的洪荒的力量，从此展开征服世界旅程。。。。。

从一个小的功能开始，比如将论坛中图片上传七牛上，这个小的功能，名字就取得通俗一点： bbs_uploader

1 创建一个新的 gem 目录：

bundle gem bbs_uploader

生成如下的目录：

bbs_uploader
├── CODE_OF_CONDUCT.md
├── Gemfile
├── LICENSE.txt
├── README.md
├── Rakefile
├── bbs_uploader.gemspec
├── bin
│   ├── console
│   └── setup
└── lib
    ├── bbs_uploader
    │   └── version.rb
    └── bbs_uploader.rb

编写并完善相关的代码，参考了 http://bbs.yundianjia.net/d/110-- 以及 https://github.com/xiajian/ruby-docx-templater 中的相关实现。

bbs_uploader.gemspec:

# coding: utf-8
lib = File.expand_path('../lib', __FILE__)
$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
require 'bbs_uploader/version'

Gem::Specification.new do |spec|
  spec.name          = "bbs_uploader"
  spec.version       = BbsUploader::VERSION
  spec.authors       = ["xiajian"]
  spec.email         = ["jhqy2011@gmail.com"]

  spec.summary       = %q{简单分装七牛上传的图片类}
  spec.description   = %q{简单封装七牛的图片上传，并演示如何创建 gem 的功能}
  spec.homepage      = "https://github.com/xiajian/bbs_uploader"
  spec.license       = "MIT"

  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
  # delete this section to allow pushing this gem to any host.
  if spec.respond_to?(:metadata)
    spec.metadata['allowed_push_host'] = "https://rubygems.org"
  else
    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
  end

  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
  spec.bindir        = "bin"
  spec.executables   = ['bbs_uploader']
  spec.require_paths = ["lib"]

  spec.add_dependency "qiniu", "~> 6.8.1"

  spec.add_development_dependency "bundler", "~> 1.10"
  spec.add_development_dependency "rake", "~> 10.0"
end

lib/bbs_uploader.rb

# 参考： http://bbs.yundianjia.net/d/110--
require "qiniu"
require "bbs_uploader/version"

module BbsUploader
  # Your code goes here...
  IMAGE_URL_REGEXP = /http:\/\/.*[jpg|png|jpeg]$/

  class << self
    @@qiniu = {}

    # 初始化全局变量 @@qiniu
    def qiniu=(options)
      @@qiniu = default_options(options)
    end

    def qiniu
      @@qiniu != {} ? @@qiniu : default_options
    end

    def default_options(options = {})
      {
          access_key: "79WvzAxvV-nOEX7m0PERzwR0Lhm-FDHriz2-QdAN",
          secret_key: "4wwnWNU16n9uVK8DHRW6qO61b2gls3aSduHswkvc",
          bucket: "bss-image",
          bucket_domain: "ognvcf5x6.bkt.clouddn.com"
      }.merge(options)
    end

    def upload_image(file_path)
      # 构建鉴权对象
      Qiniu.establish_connection! access_key: self.qiniu[:access_key],
                                  secret_key: self.qiniu[:secret_key]

      key = "bbs_image/#{File.basename(file_path)}"
      put_policy = Qiniu::Auth::PutPolicy.new(
          self.qiniu[:bucket], # 存储空间
          key, # 指定上传的资源名，如果传入 nil，就表示不指定资源名，将使用默认的资源名
          3600 # token 过期时间，默认为 3600 秒，即 1 小时
      )

      uptoken = Qiniu::Auth.generate_uptoken(put_policy)

      # 调用 upload_with_token_2 方法上传
      code, result = Qiniu::Storage.upload_with_token_2(
          uptoken,
          file_path,
          key,
          nil, # 可以接受一个 Hash 作为自定义变量，请参照 http://developer.qiniu.com/article/kodo/kodo-developer/up/vars.html#xvar
          bucket: self.qiniu[:bucket]
      )

      if code == 200
        image_url = "http://#{self.qiniu[:bucket_domain]}/#{result['key']}"

        puts "图片上传成功! \n链接为: #{image_url} \nmarkdown 链接: #{markdown_image_link(image_url)}"

        image_url
      else
        puts '上传图片失败'

        nil
      end
    rescue => e
      puts "上传图片发生异常: #{e}"

      nil
    end

    def markdown_image_link(image_url)
      if image_url && image_url.is_a?(String) && IMAGE_URL_REGEXP.match(image_url)
        "![](#{image_url})"
      else
        ''
      end
    end

    # 根据目录下指定目录下的文件，将文件上传到七牛上
    #
    # @note 注意文件需要按照文件目录的自然顺序
    def generate_markdown_format(dir)
      content = ''
      files = []

      `ls #{dir}`.split('\n').map { |filename| files << "#{dir}/#{filename}" }

      files.each do |file|
        content <<  markdown_image_link(upload_image(file)) + "\n"
      end

      puts content

      content
    end
  end
end

bin/bbs_uploader

#!/usr/bin/env ruby

require 'json'
require 'psych'
require 'optparse'
require 'bundler/setup'
require 'bbs_uploader'

options = {}

OptionParser.new do |opts|
  opts.banner = "Usage: bbs_uploader [options]"

  opts.on_tail('-h', '--help', 'Show this message') do
    puts opts
    exit
  end

  opts.on_tail('-v', '--version', 'Print version') do
    puts "bbs_uploader #{BbsUploader::VERSION}"
    exit
  end

  opts.on('-i', '--input-file [file]', 'Default: xxx.jpg') do |file|
    unless File.exist? file
      puts "输入的文件 #{file} 不存在，请检查后重试"
      exit
    end

    options[:input_file] = File.absolute_path file
  end
end.parse!

if options[:input_file].nil?
  file = ARGV[0]

  if !file.nil? && File.exists?(file)
    options[:input_file] = File.absolute_path file
  elsif !file.nil?
    puts "输入的文件 #{ARGV[0]} 不存在，请检查后重试"
    exit
  elsif file.nil?
    puts "没有选择上传的图片"
    exit
  end
end

BbsUploader.upload_image options[:input_file]

至此，代码算是也好了，可以在本地测试一下，是否正常：

bin/bbs_uploader /Users/xiajian/Downloads/test.jpg
D, [2016-11-15T13:09:03.811865 #23391] DEBUG -- : Query bss-image hosts Success: {"ttl"=>86400, "http"=>{"io"=>["http://iovip.qbox.me"], "up"=>["http://up.qiniu.com", "http://upload.qiniu.com", "-H up.qiniu.com http://183.136.139.16"]}, "https"=>{"io"=>["https://iovip.qbox.me"], "up"=>["https://up.qbox.me"]}}
图片上传成功!
链接为: http://ognvcf5x6.bkt.clouddn.com/bbs_image/test.jpg
markdown 链接: ![](http://ognvcf5x6.bkt.clouddn.com/bbs_image/test.jpg)

在 github 上新建一个同名的版本库，并将代码推送上去。

在项目中执行，将代码推送到远程：

git init
git add -A
git commit -m"first comment"
git remote add origin git@github.com:xiajian/bbs_uploader.git
git push -u origin master

配置 Rubygems 相关的配置，详情可以参考 http://bbs.yundianjia.net/d/95-rubygem-gem

执行 rake release 发布 gem 包。

$ rake release
bbs_uploader 0.1.0 built to pkg/bbs_uploader-0.1.0.gem.
Tagged v0.1.0.
Pushed git commits and tags.
Pushed bbs_uploader 0.1.0 to rubygems.org.

rubygems 上项目的地址： https://rubygems.org/gems/bbs_uploader

此刻，过个 30 分钟（taobao 同步 Rubygems 的时间间隔的 2 倍），就可以 gem install bbs_uploader

使用指南：

命令行使用：

使用指南：

Usage: bbs_uploader [options]
    -i, --input-file [file]          Default: xxx.jpg
    -h, --help                       Show this message
    -v, --version                    Print version

调用实例：

bbs_uploader ~/Downloads/test.jpg
D, [2016-11-15T16:31:52.906672 #30130] DEBUG -- : Query bss-image hosts Success: {"ttl"=>86400, "http"=>{"io"=>["http://iovip.qbox.me"], "up"=>["http://up.qiniu.com", "http://upload.qiniu.com", "-H up.qiniu.com http://183.136.139.16"]}, "https"=>{"io"=>["https://iovip.qbox.me"], "up"=>["https://up.qbox.me"]}}
图片上传成功!
链接为: http://ognvcf5x6.bkt.clouddn.com/bbs_image/test.jpg
markdown 链接: ![](http://ognvcf5x6.bkt.clouddn.com/bbs_image/test.jpg)

编程使用：

BbsUploader.qiniu = {
  access_key: 'your access key',
  secret_key: 'your secret key',
  bucket: "your bucket",
  bucket_domain: "your application domain"
}

BbsUploader.upload_image '~/Downloads/test.jpg'

至此，全文完！！！！

如何将转换成字符串的对象，重新转换成对象？

xiajian — Fri, 18 Mar 2016 20:31:09 +0800

如何将转换成字符串的对象，重新转换成对象。具体的就是，将 hash 对象存放到 redis 之后，再取出来，恢复成一个 hash 对象。

比如，我有一个 hash 对象 a1:

[102] pry(main)> a123
=> {"aeopPostCategoryList"=>
  [{"id"=>3,
    "level"=>0,
    "names"=>{"zh"=>"服装/服饰配件", "pt"=>"Vestuário e acessórios", "fr"=>"Vêtements & accessoires", "en"=>"Apparel & Accessories", "ru"=>"Одежда и аксессуары", "es"=>"Ropa y accesorios", "in"=>"Pakaian & aksesoris"},
    "isleaf"=>false},
   {"id"=>34,
    "level"=>0,
    "names"=>{"zh"=>"汽车、摩托车", "pt"=>"Automóveis e motos", "fr"=>"Automobiles et motos", "en"=>"Automobiles & Motorcycles", "ru"=>"Автомобили и мотоциклы", "es"=>"Automóviles y motocicletas", "in"=>"Mobil & sepeda motor"},
    "isleaf"=>false},
   {"id"=>66, "level"=>0, "names"=>{"zh"=>"美容健康", "pt"=>"Beleza e saúde", "fr"=>"Beauté & santé", "en"=>"Beauty & Health", "ru"=>"Красоты и здоровья", "es"=>"Belleza y salud", "in"=>"Kecantikan & kesehatan"}, "isleaf"=>false},
   {"id"=>200004360,
    "level"=>0,
    "names"=>{"zh"=>"俄罗斯当地图书销售", "pt"=>"Livros locais para russo", "fr"=>"Livres pour locale russe", "en"=>"Books for Local Russian", "ru"=>"Книги для местных русский", "es"=>"Libros para Local ruso", "in"=>"Buku untuk lokal Russian"},
    "isleaf"=>false},
   {"id"=>7,
    "level"=>0,
    "names"=>{"zh"=>"电脑和办公", "pt"=>"Computador e escritório", "fr"=>"Ordinateur et bureau", "en"=>"Computer & Office", "ru"=>"Компьютер и офиса", "es"=>"Ordenador y oficina", "in"=>"Komputer & kantor"},
    "isleaf"=>false},
   {"id"=>13,
    "level"=>0,
    "names"=>
     {"zh"=>"建筑", "pt"=>"Construção & Real Estate", "fr"=>"Immobilier & Construction", "en"=>"Construction & Real Estate", "ru"=>"Строительство и недвижимость", "es"=>"Construcción y bienes raíces", "in"=>"Konstruksi & Real Estate"},
    "isleaf"=>false},
   {"id"=>44,
    "level"=>0,
    "names"=>{"zh"=>"消费电子", "pt"=>"Eletrônicos de consumo", "fr"=>"Consumer Electronics", "en"=>"Consumer Electronics", "ru"=>"Бытовая электроника", "es"=>"Electrónica de consumo", "in"=>"Elektronik konsumen"},
    "isleaf"=>false},
   {"id"=>100008578,
    "level"=>0,
    "names"=>{"zh"=>"定制化产品", "pt"=>"Produtos personalizados", "fr"=>"Produits personnalisés", "en"=>"Customized Products", "ru"=>"Настроенные продукты", "es"=>"Productos personalizados", "in"=>"Produk disesuaikan"},
    "isleaf"=>false},
   {"id"=>5,
    "level"=>0,
    "names"=>
     {"zh"=>"电气设备和产品",
      "pt"=>"Equipamentos eléctricos e suprimentos",
      "fr"=>"Electrical Equipment & Supplies",
      "en"=>"Electrical Equipment & Supplies",
      "ru"=>"Электротехника и дополнения",
      "es"=>"Equipo eléctrico y suministros",
      "in"=>"Peralatan listrik & perlengkapan"},
    "isleaf"=>false},

其存放到 redis 中，再取出来就变成这样了：

"{\"aeopPostCategoryList\"=>[{\"id\"=>3, \"level\"=>0, \"names\"=>{\"zh\"=>\"服装/服饰配件\", \"pt\"=>\"Vestuário e acessórios\", \"fr\"=>\"Vêtements & accessoires\", \"en\"=>\"Apparel & Accessories\", \"ru\"=>\"Одежда и аксессуары\", \"es\"=>\"Ropa y accesorios\", \"in\"=>\"Pakaian & aksesoris\"}, \"isleaf\"=>false}, {\"id\"=>34, \"level\"=>0, \"names\"=>{\"zh\"=>\"汽车、摩托车\", \"pt\"=>\"Automóveis e motos\", \"fr\"=>\"Automobiles et motos\", \"en\"=>\"Automobiles & Motorcycles\", \"ru\"=>\"Автомобили и мотоциклы\", \"es\"=>\"Automóviles y motocicletas\", \"in\"=>\"Mobil & sepeda motor\"}, \"isleaf\"=>false}, {\"id\"=>66, \"level\"=>0, \"names\"=>{\"zh\"=>\"美容健康\", \"pt\"=>\"Beleza e saúde\", \"fr\"=>\"Beauté & santé\", \"en\"=>\"Beauty & Health\", \"ru\"=>\"Красоты и здоровья\", \"es\"=>\"Belleza y salud\", \"in\"=>\"Kecantikan & kesehatan\"}, \"isleaf\"=>false}, {\"id\"=>200004360, \"level\"=>0, \"names\"=>{\"zh\"=>\"俄罗斯当地图书销售\", \"pt\"=>\"Livros locais para russo\", \"fr\"=>\"Livres pour locale russe\", \"en\"=>\"Books for Local Russian\", \"ru\"=>\"Книги для местных русский\", \"es\"=>\"Libros para Local ruso\", \"in\"=>\"Buku untuk lokal Russian\"}, \"isleaf\"=>false}, {\"id\"=>7, \"level\"=>0, \"names\"=>{\"zh\"=>\"电脑和办公\", \"pt\"=>\"Computador e escritório\", \"fr\"=>\"Ordinateur et bureau\", \"en\"=>\"Computer & Office\", \"ru\"=>\"Компьютер и офиса\", \"es\"=>\"Ordenador y oficina\", \"in\"=>\"Komputer & kantor\"}, \"isleaf\"=>false}, {\"id\"=>13, \"level\"=>0, \"names\"=>{\"zh\"=>\"建筑\", \"pt\"=>\"Construção & Real Estate\", \"fr\"=>\"Immobilier & Construction\", \"en\"=>\"Construction & Real Estate\", \"ru\"=>\"Строительство и недвижимость\", \"es\"=>\"Construcción y bienes raíces\", \"in\"=>\"Konstruksi & Real Estate\"}, \"isleaf\"=>false}, {\"id\"=>44, \"level\"=>0, \"names\"=>{\"zh\"=>\"消费电子\", \"pt\"=>\"Eletrônicos de consumo\", \"fr\"=>\"Consumer Electronics\", \"en\"=>\"Consumer Electronics\", \"ru\"=>\"Бытовая электроника\", \"es\"=>\"Electrónica de consumo\", \"in\"=>\"Elektronik konsumen\"}, \"isleaf\"=>false}, {\"id\"=>100008578, \"level\"=>0, \"names\"=>{\"zh\"=>\"定制化产品\", \"pt\"=>\"Produtos personalizados\", \"fr\"=>\"Produits personnalisés\", \"en\"=>\"Customized Products\", \"ru\"=>\"Настроенные продукты\", \"es\"=>\"Productos personalizados\", \"in\"=>\"Produk disesuaikan\"}, \"isleaf\"=>false}, {\"id\"=>5, \"level\"=>0, \"names\"=>{\"zh\"=>\"电气设备和产品\", \"pt\"=>\"Equipamentos eléctricos e suprimentos\", \"fr\"=>\"Electrical Equipment & Supplies\", \"en\"=>\"Electrical Equipment & Supplies\", \"ru\"=>\"Электротехника и дополнения\", \"es\"=>\"Equipo eléctrico y suministros\", \"in\"=>\"Peralatan listrik & perlengkapan\"}, \"isleaf\"=>false}, {\"id\"=>502, \"level\"=>0, \"names\"=>{\"zh\"=>\"电子元器件\", \"pt\"=>\"Componentes e sistemas electrónicas\", \"fr\"=>\"Composants électroniques et les\", \"en\"=>\"Electronic Components & Supplies\", \"ru\"=>\"Электронных компонентов и расходных материалов\", \"es\"=>\"Componentes y sistemas electrónicos\", \"in\"=>\"Komponen elektronik & perlengkapan\"}, \"isleaf\"=>false}, {\"id\"=>2, \"level\"=>0, \"names\"=>{\"zh\"=>\"食品\", \"pt\"=>\"Alimentos\", \"fr\"=>\"Alimentaire\", \"en\"=>\"Food\", \"ru\"=>\"Питание\", \"es\"=>\"Alimentos\", \"in\"=>\"Makanan\"}, \"isleaf\"=>false}, {\"id\"=>1503, \"level\"=>0, \"names\"=>{\"zh\"=>\"家具和室内装饰品\", \"pt\"=>\"Móveis\", \"fr\"=>\"Meubles\", \"en\"=>\"Furniture\", \"ru\"=>\"Мебель\", \"es\"=>\"Muebles\", \"in\"=>\"Furniture\"}, \"isleaf\"=>false}, {\"id\"=>200003655, \"level\"=>0, \"names\"=>{\"zh\"=>\"假发及周边\", \"pt\"=>\"Cabelo e acessórios\", \"fr\"=>\"Cheveux et accessoires\", \"en\"=>\"Hair & Accessories\", \"ru\"=>\"Волосы и аксессуары\", \"es\"=>\"Pelo y accesorios\", \"in\"=>\"Rambut & aksesoris\"}, \"isleaf\"=>false}, {\"id\"=>42, \"level\"=>0, \"names\"=>{\"zh\"=>\"五金\", \"pt\"=>\"Hardware\", \"fr\"=>\"Matériel\", \"en\"=>\"Hardware\", \"ru\"=>\"Оборудование\", \"es\"=>\"Hardware\", \"in\"=>\"Hardware\"}, \"isleaf\"=>false}, {\"id\"=>15, \"level\"=>0, \"names\"=>{\"zh\"=>\"家居用品\", \"pt\"=>\"Casa e jardim\", \"fr\"=>\"Maison & jardin\", \"en\"=>\"Home & Garden\", \"ru\"=>\"Дома и сада\", \"es\"=>\"Hogar y jardín\", \"in\"=>\"Home & Garden\"}, \"isleaf\"=>false}, {\"id\"=>6, \"level\"=>0, \"names\"=>{\"zh\"=>\"家用电器\", \"pt\"=>\"Eletrodomésticos\", \"fr\"=>\"Appareils ménagers\", \"en\"=>\"Home Appliances\", \"ru\"=>\"Бытовая техника\", \"es\"=>\"Electrodomésticos\", \"in\"=>\"Peralatan rumah\"}, \"isleaf\"=>false}, {\"id\"=>200001996, \"level\"=>0, \"names\"=>{\"zh\"=>\"工业/原材料/商业用品\", \"pt\"=>\"Indústria e negócios\", \"fr\"=>\"Industrie et d'affaires\", \"en\"=>\"Industry & Business\", \"ru\"=>\"Промышленности и бизнес\", \"es\"=>\"Industria y negocio\", \"in\"=>\"Industri & bisnis\"}, \"isleaf\"=>false}, {\"id\"=>36, \"level\"=>0, \"names\"=>{\"zh\"=>\"珠宝手表\", \"pt\"=>\"Jóias & relógios\", \"fr\"=>\"Bijoux et montre\", \"en\"=>\"Jewelry & Watch\", \"ru\"=>\"Ювелирные изделия и часы\", \"es\"=>\"Joyería y reloj\", \"in\"=>\"Perhiasan & menonton\"}, \"isleaf\"=>false}, {\"id\"=>39, \"level\"=>0, \"names\"=>{\"zh\"=>\"照明灯饰\", \"pt\"=>\"Luzes\", \"fr\"=>\"Lumières et éclairage\", \"en\"=>\"Lights & Lighting\", \"ru\"=>\"Огни и освещение\", \"es\"=>\"Luces e iluminación\", \"in\"=>\"Lampu & pencahayaan\"}, \"isleaf\"=>false}, {\"id\"=>1524, \"level\"=>0, \"names\"=>{\"zh\"=>\"箱包\", \"pt\"=>\"Bagagem & Bags\", \"fr\"=>\"Bagages et sacs\", \"en\"=>\"Luggage & Bags\", \"ru\"=>\"Багажа и сумки\", \"es\"=>\"Equipaje y bolsas\", \"in\"=>\"Bagasi & tas\"}, \"isleaf\"=>false}, {\"id\"=>1501, \"level\"=>0, \"names\"=>{\"zh\"=>\"孕婴童\", \"pt\"=>\"Mãe & Kids\", \"fr\"=>\"Mère et enfants\", \"en\"=>\"Mother & Kids\", \"ru\"=>\"Мать и дети\", \"es\"=>\"La madre y de los niños\", \"in\"=>\"Ibu & anak-anak\"}, \"isleaf\"=>false}, {\"id\"=>21, \"level\"=>0, \"names\"=>{\"zh\"=>\"办公文教用品\", \"pt\"=>\"Escritório e material escolar\", \"fr\"=>\"Bureau et fournitures scolaires\", \"en\"=>\"Office & School Supplies\", \"ru\"=>\"Офисные и школьные принадлежности\", \"es\"=>\"Office & School Supplies\", \"in\"=>\"Office & School Supplies\"}, \"isleaf\"=>false}, {\"id\"=>509, \"level\"=>0, \"names\"=>{\"zh\"=>\"电话和通讯\", \"pt\"=>\"Telefones e telecomunicações\", \"fr\"=>\"Téléphones et télécommunications\", \"en\"=>\"Phones & Telecommunications\", \"ru\"=>\"Телефоны и телекоммуникации\", \"es\"=>\"Teléfonos y telecomunicaciones\", \"in\"=>\"Ponsel & telekomunikasi\"}, \"isleaf\"=>false}, {\"id\"=>30, \"level\"=>0, \"names\"=>{\"zh\"=>\"安全防护\", \"pt\"=>\"Segurança e proteção\", \"fr\"=>\"Sécurité et Protection\", \"en\"=>\"Security & Protection\", \"ru\"=>\"Безопасности и защиты\", \"es\"=>\"Seguridad y protección\", \"in\"=>\"Keamanan & perlindungan\"}, \"isleaf\"=>false}, {\"id\"=>322, \"level\"=>0, \"names\"=>{\"zh\"=>\"鞋子\", \"pt\"=>\"Sapatos\", \"fr\"=>\"Chaussures\", \"en\"=>\"Shoes\", \"ru\"=>\"Обувь\", \"es\"=>\"Zapatos\", \"in\"=>\"Sepatu\"}, \"isleaf\"=>false}, {\"id\"=>200001075, \"level\"=>0, \"names\"=>{\"zh\"=>\"其他特殊类\", \"pt\"=>\"Categoria especial\", \"fr\"=>\"Catégorie spéciale\", \"en\"=>\"Special Category\", \"ru\"=>\"Специальная категория\", \"es\"=>\"Especial categoría\", \"in\"=>\"Kategori khusus\"}, \"isleaf\"=>false}, {\"id\"=>18, \"level\"=>0, \"names\"=>{\"zh\"=>\"运动及娱乐\", \"pt\"=>\"Esporte e lazer\", \"fr\"=>\"Sports & Entertainment\", \"en\"=>\"Sports & Entertainment\", \"ru\"=>\"Спорт и развлечения\", \"es\"=>\"Deportes y entretenimiento\", \"in\"=>\"Olahraga & hiburan\"}, \"isleaf\"=>false}, {\"id\"=>1420, \"level\"=>0, \"names\"=>{\"zh\"=>\"工具\", \"pt\"=>\"Ferramentas\", \"fr\"=>\"Outils\", \"en\"=>\"Tools\", \"ru\"=>\"Инструменты\", \"es\"=>\"Herramientas\", \"in\"=>\"Alat\"}, \"isleaf\"=>false}, {\"id\"=>26, \"level\"=>0, \"names\"=>{\"zh\"=>\"玩具\", \"pt\"=>\"Brinquedos e Hobbies\", \"fr\"=>\"Jouets & loisirs\", \"en\"=>\"Toys & Hobbies\", \"ru\"=>\"Игрушки и хобби\", \"es\"=>\"Juguetes y pasatiempos\", \"in\"=>\"Mainan & hobi\"}, \"isleaf\"=>false}, {\"id\"=>200003498, \"level\"=>0, \"names\"=>{\"zh\"=>\"旅游及代金券\", \"pt\"=>\"Viagens e serviços de cupom\", \"fr\"=>\"Voyage promo Services\", \"en\"=>\"Travel and Coupon Services\", \"ru\"=>\"Путешествия и купон услуги\", \"es\"=>\"Viajes y cupón servicios\", \"in\"=>\"Perjalanan dan jasa kupon\"}, \"isleaf\"=>false}, {\"id\"=>320, \"level\"=>0, \"names\"=>{\"zh\"=>\"婚礼及重要场合\", \"pt\"=>\"Casamentos e eventos\", \"fr\"=>\"Mariages et événements\", \"en\"=>\"Weddings & Events\", \"ru\"=>\"Свадьбы и события\", \"es\"=>\"Bodas y eventos\", \"in\"=>\"Pernikahan & acara\"}, \"isleaf\"=>false}], \"success\"=>true}"

使用，JSON.parse 貌似不行。

Redis-objects 介绍

xiajian — Mon, 25 May 2015 10:39:45 +0800

注：官方 Readme 的翻译，译的不好，还请各位指正

Redis::Objects - Map Redis types directly to Ruby objects , 将 Redis 类型直接映射为 Ruby 对象。

This is not an ORM. People that are wrapping ORM’s around Redis are missing the point.

这并不是 ORM，想要在 Redis 上包装 ORM 的人未得要领。

The killer feature of Redis is that it allows you to perform atomic operations on individual data structures, like counters, lists, and sets. The atomic part is HUGE. Using an ORM wrapper that retrieves a "record", updates values, then sends those values back, removes the atomicity, cutting the nuts off the major advantage of Redis. Just use MySQL, k?

Redis 的杀手级特性是：可以在单独的数据结构 (比如计数器，列表，集合) 上执行原子性的操作，其中原子性部分作用是巨大的。使用 ORM 层来检索记录，更新值，回送值，删除值将会抵消原子性的作用，从而不能发挥 Redis 的巨大优势。要 ORM，直接用 MySQL 就好了。

This gem provides a Rubyish interface to Redis, by mapping Redis data types to Ruby objects, via a thin layer over the redis gem. It offers several advantages over the lower-level redis-rb API:

该 gem 提供了 Redis 的 Rubyish 接口，将Redis data types映射为 Ruby 对象。通过对redisgem 的薄封装，相对 redis-rb API， redis-objects 提供如下的一些优势：

Easy to integrate directly with existing ORMs - ActiveRecord, DataMapper, etc. Add counters to your model!
很容易集成到现有的 ORM 中，诸如 ActiveRecord, DataMapper 之类。并向模型中添加计数器。
Complex data structures are automatically Marshaled (if you set :marshal => true)
复杂的数据结构将自动序列化 (设置:marshal => true )
Integers are returned as integers, rather than '17'
整数就按整数返回，而不是'17'
Higher-level types are provided, such as Locks, that wrap multiple calls
提供高层次的类型，比如 Locks(锁) - 包装了多个调用

This gem originally arose out of a need for high-concurrency atomic operations; for a fun rant on the topic, see An Atomic Rant, or scroll down to Atomic Counters and Locks in this README.

gem 起源于高并发的原子操作的需求; 关于该话题的有趣咆哮 - An Atomic Rant, 或者滚动到 Atomic Counters and Locks的章节处。

There are two ways to use Redis::Objects, either as an include in a model class (to tightly integrate with ORMs or other classes), or standalone by using classes such as Redis::List and Redis::SortedSet.

存在两种使用Redis::Objects的方式：

在 model 类中使用，即与 ORM 或其他类紧密集合
单独使用诸如Redis::List和Redis::SortedSet这样的类

安装和设置 (Installation and Setup)

在 Gemfile 中添加如下内容：

gem 'redis-objects'

Redis::Objects needs a handle created by Redis.new or a ConnectionPool:

Redis::Objects 需要由Redis.new创建的句柄，或者一个连接池 (ConnectionPool):

The recommended approach is to use a ConnectionPool since this guarantees that most timeouts in the redis client do not pollute your existing connection. However, you need to make sure that both :timeout and :size are set appropriately in a multithreaded environment.

推荐使用ConnectionPool，这样能够保证redis客户端不会污染现有的连接。但是，在多线程的环境中，需要确保正确的设置:timeout和:size。

require 'connection_pool'
Redis::Objects.redis = ConnectionPool.new(size: 5, timeout: 5) { Redis.new(:host => '127.0.0.1', :port => 6379) }

Redis::Objects can also default to Redis.current if Redis::Objects.redis is not set.

如果Redis::Objects.redis没有设置，Redis::Objects 将会默认使用Redis.current。

Redis.current = Redis.new(:host => '127.0.0.1', :port => 6379)

如果在 Rails 中，这些配置可以放在config/initializers/redis.rb

Remember you can use Redis::Objects in any Ruby code. There are no dependencies on Rails. Standalone, Sinatra, Resque - no problem.

记住，可以在任意的 Ruby 代码中使用 Redis::Objects，其并不依赖 Rails。单独使用，在 Sinatra 或 Resque 中，都没有问题。

Alternatively, you can set the redis handle directly:

当然，也可直接是设置redis句柄：

Redis::Objects.redis = Redis.new(...)

Finally, you can even set different handles for different classes:

最后，可以为不同的类设置不同的句柄：

class User
  include Redis::Objects
end
class Post
  include Redis::Objects
end

# you can also use a ConnectionPool here as well
User.redis = Redis.new(:host => '1.2.3.4')
Post.redis = Redis.new(:host => '5.6.7.8')

As of 0.7.0, redis-objects now autoloads the appropriate Redis::Whatever classes on demand. Previous strategies of individually requiring redis/list or redis/set are no longer required.

在0.7.0，redis-objects可以在恰当的时候，自动加载Redis::Whatever类。先前需要单独引入redis/list或redis/set的方式不再需要。

场景 1：在 Model 类中包含 Redis::Objects

Including Redis::Objects in a model class makes it trivial to integrate Redis types with an existing ActiveRecord, DataMapper, Mongoid, or similar class. Redis::Objects will work with any class that provides an id method that returns a unique value. Redis::Objects automatically creates keys that are unique to each object, in the format:

在模型类中包含 Redis::Objects，从而将 Redis 类型整合进现存的 ActiveRecord，DataMapper，Mongoid，或单个类中。 Redis::Objects 可以在任何提供了 id 方法 (返回独一无二的值) 的类中工作. Redis::Objects 将自动创建针对每个对象创建独特的键，以如下的格式：

model_namefield_name

For illustration purposes, consider this stub class:

为了演示处理，考虑如下的桩类：

class User
  include Redis::Objects
  counter :my_posts
  def id
    1
  end
end

user = User.new
user.id  # 1
user.my_posts.increment
user.my_posts.increment
user.my_posts.increment
puts user.my_posts.value # 3
user.my_posts.reset
puts user.my_posts.value # 0
user.my_posts.reset 5
puts user.my_posts.value # 5

Here's an example that integrates several data types with an ActiveRecord model:

如下，是将一些 Redis 数据类型集成到 ActiveRecord 模型中的例子：

class Team < ActiveRecord::Base
  include Redis::Objects

  lock :trade_players, :expiration => 15  # sec
  value :at_bat
  counter :hits
  counter :runs
  counter :outs
  counter :inning, :start => 1
  list :on_base
  list :coaches, :marshal => true
  set  :outfielders
  hash_key :pitchers_faced  # "hash" is taken by Ruby
  sorted_set :rank, :global => true
end

列表类型与 Ruby 的数组操作类似：

@team = Team.find_by_name('New York Yankees')
@team.on_base << 'player1'
@team.on_base << 'player2'
@team.on_base << 'player3'
@team.on_base    # ['player1', 'player2', 'player3']
@team.on_base.pop
@team.on_base.shift
@team.on_base.length  # 1
@team.on_base.delete('player2')

集合的操作也类似：

@team.outfielders << 'outfielder1'
@team.outfielders << 'outfielder2'
@team.outfielders << 'outfielder1'   # dup ignored
@team.outfielders  # ['outfielder1', 'outfielder2']
@team.outfielders.each do |player|
  puts player
end
player = @team.outfielders.detect{|of| of == 'outfielder2'}

可以在对象之间取交集和并集操作，非常酷：

@team1.outfielders | @team2.outfielders   # outfielders on both teams
@team1.outfielders & @team2.outfielders   # in baseball, should be empty :-)

Counters can be atomically incremented/decremented (but not assigned):

计数器可以原子的增加或减少，但不能赋值：

@team.hits.increment  # or incr
@team.hits.decrement  # or decr
@team.hits.incr(3)    # add 3
@team.runs = 4        # exception

定义一个像id变量那样的方法非常的容易：

class User
  include Redis::Objects
  redis_id_field :uid
  counter :my_posts
end

user.uid                # 195137a1bdea4473
user.my_posts.increment # 1

Finally, for free, you get a redis method that points directly to a Redis connection:

最后，将免费的得到一个指向 Redis 连接的redis方法：

Team.redis.get('somekey')
@team = Team.new
@team.redis.get('somekey')
@team.redis.smembers('someset')

可以使用redis直接调用任何Redis API command。

Option 2: Standalone Usage

There is a Ruby class that maps to each Redis type, with methods for each Redis API command.

有一些将 Ruby 类直接映射成 Redis 类型，并提供了针对Redis API command的相应方法。

Note that calling new does not imply it's actually a "new" value - it just creates a mapping between that Ruby object and the corresponding Redis data structure, which may already exist on the redis-server.

注意，这里调用new方法，并不意味创建一个"新"的值 - 它只是创建了一个从 Redis 数据结构到 Ruby 对象之间的映射，而前者已经在redis-server中存在。

Counters

counter_name是 Redis 中存储的键。

@counter = Redis::Counter.new('counter_name')
@counter.increment  # or incr
@counter.decrement  # or decr
@counter.increment(3)
puts @counter.value

gem 也提供了干净的方法去处理原子性的块：

@counter.increment do |val|
  raise "Full" if val > MAX_VAL  # rewind counter
end

See the section on Atomic Counters and Locks for cool uses of atomic counter blocks.

查看Atomic Counters and Locks章节，找到更多很酷的原子计数块。

Locks

A convenience class that wraps the pattern of using setnx to perform locking.

Lock 是包装了using setnx to perform locking模式的极其方便的类：

@lock = Redis::Lock.new('serialize_stuff', :expiration => 15, :timeout => 0.1)
@lock.lock do
  # do work
end

This can be especially useful if you're running batch jobs spread across multiple hosts.

这在运行分散在多台主机上的批量 job 时，非常有用。

Values

Value 对象中，简单对象很好处理：

@value = Redis::Value.new('value_name')
@value.value = 'a'
@value.delete

复杂的对象使用:marshal => true也没多大问题：

@account = Account.create!(params[:account])
@newest  = Redis::Value.new('newest_account', :marshal => true)
@newest.value = @account.attributes
puts @newest.value['username']

Lists

列表的操作与 Ruby 数组类似：

@list = Redis::List.new('list_name')
@list << 'a'
@list << 'b'
@list.include? 'c'   # false
@list.values  # ['a','b']
@list << 'c'
@list.delete('c')
@list[0]
@list[0,1]
@list[0..1]
@list.shift
@list.pop
@list.clear
# etc

可以限定列表的大小，使其仅存放 N 个元素：

# Only holds 10 elements, throws out old ones when you reach :maxlength.
@list = Redis::List.new('list_name', :maxlength => 10)

Complex data types are now handled with :marshal => true:

复杂的数据可以通过设置:marshal => true:

@list = Redis::List.new('list_name', :marshal => true)
@list << {:name => "Nate", :city => "San Diego"}
@list << {:name => "Peter", :city => "Oceanside"}
@list.each do |el|
  puts "#{el[:name]} lives in #{el[:city]}"
end

Hashes

Hashes work like a Ruby Hash, with a few Redis-specific additions. (The class name is "HashKey" not just "Hash", due to conflicts with the Ruby core Hash class in other gems.)

Hash 与 Ruby 的 Ruby Hash作用类似，并带有一些 Redis 特定的附加特性。类名为 HashKey，而不是 Hash，是为了避免与 Ruby core 的冲突。

@hash = Redis::HashKey.new('hash_name')
@hash['a'] = 1
@hash['b'] = 2
@hash.each do |k,v|
  puts "#{k} = #{v}"
end
@hash['c'] = 3
puts @hash.all  # {"a"=>"1","b"=>"2","c"=>"3"}
@hash.clear

Redis 也添加了自增以及 bulk 的操作 (??):

@hash.incr('c', 6)  # 9
@hash.bulk_set('d' => 5, 'e' => 6)
@hash.bulk_get('d','e')  # "5", "6"

Remember that numbers become strings in Redis. Unlike with other Redis data types, redis-objects can't guess at your data type in this situation, since you may actually mean to store "1.5".

注意：Redis 中将字符存作数字。与其他 Redis 数据类型不同，redis-objects并在这种情况下，猜测数据类型，因为你有可能想存的是"1.5"。

Sets

Sets work like the Ruby Set class. They are unordered, but guarantee uniqueness of members.

Set 类型与 Ruby 的Set类型相似，其是无序且不重复的。

@set = Redis::Set.new('set_name')
@set << 'a'
@set << 'b'
@set << 'a'  # dup ignored
@set.member? 'c'      # false
@set.members          # ['a','b']
@set.members.reverse  # ['b','a']
@set.each do |member|
  puts member
end
@set.clear
# etc

可以很方便的执行交并补差等运算：

@set1 = Redis::Set.new('set1')
@set2 = Redis::Set.new('set2')
@set3 = Redis::Set.new('set3')
members = @set1 & @set2   # intersection
members = @set1 | @set2   # union
members = @set1 + @set2   # union
members = @set1 ^ @set2   # difference
members = @set1 - @set2   # difference
members = @set1.intersection(@set2, @set3)  # multiple
members = @set1.union(@set2, @set3)         # multiple
members = @set1.difference(@set2, @set3)    # multiple

或者，将其存到 Redis 中：

@set1.interstore('intername', @set2, @set3)
members = @set1.redis.get('intername')
@set1.unionstore('unionname', @set2, @set3)
members = @set1.redis.get('unionname')
@set1.diffstore('diffname', @set2, @set3)
members = @set1.redis.get('diffname')

同上，复杂的数据类型可以使用:marshal => true :

@set1 = Redis::Set.new('set1', :marshal => true)
@set2 = Redis::Set.new('set2', :marshal => true)
@set1 << {:name => "Nate",  :city => "San Diego"}
@set1 << {:name => "Peter", :city => "Oceanside"}
@set2 << {:name => "Nate",  :city => "San Diego"}
@set2 << {:name => "Jeff",  :city => "Del Mar"}

@set1 & @set2  # Nate
@set1 - @set2  # Peter
@set1 | @set2  # all 3 people

Sorted Sets

Due to their unique properties, Sorted Sets work like a hybrid between a Hash and an Array. You assign like a Hash, but retrieve like an Array:

由于有序集合独特的特性，其更像哈希 (Hash) 和数组的混合体 - 即像 Hash 那样赋值，像数组那样检索：

@sorted_set = Redis::SortedSet.new('number_of_posts') # 建立键名为`number_of_posts`的有序集合
@sorted_set['Nate']  = 15
@sorted_set['Peter'] = 75
@sorted_set['Jeff']  = 24

# Array access to get sorted order
@sorted_set[0..2]           # => ["Nate", "Jeff", "Peter"]
@sorted_set[0,2]            # => ["Nate", "Jeff"]

@sorted_set['Peter']        # => 75
@sorted_set['Jeff']         # => 24
@sorted_set.score('Jeff')   # same thing (24)，这里说，score与[]方法作用相同

@sorted_set.rank('Peter')   # => 2
@sorted_set.rank('Jeff')    # => 1

@sorted_set.first           # => "Nate"
@sorted_set.last            # => "Peter"
@sorted_set.revrange(0,2)   # => ["Peter", "Jeff", "Nate"]

@sorted_set['Newbie'] = 1
@sorted_set.members         # => ["Newbie", "Nate", "Jeff", "Peter"]
@sorted_set.members.reverse # => ["Peter", "Jeff", "Nate", "Newbie"]

@sorted_set.rangebyscore(10, 100, :limit => 2)   # => ["Nate", "Jeff"]
@sorted_set.members(:with_scores => true)        # => [["Newbie", 1], ["Nate", 16], ["Jeff", 28], ["Peter", 76]]

# atomic increment
@sorted_set.increment('Nate')
@sorted_set.incr('Peter')   # shorthand
@sorted_set.incr('Jeff', 4)

The other Redis Sorted Set commands are supported as well; see Sorted Sets API.

其他的 Redis 有序集合的命令也支持，具体参考Sorted Sets API。

Atomic Counters and Locks

You are probably not handling atomicity correctly in your app. For a fun rant on the topic, see An Atomic Rant.

你可能不能在应用中正确的处理原子性。正如那个有趣的咆哮所言：An Atomic Rant

Atomic counters are a good way to handle concurrency:

原子计数是处理并发的好方法，例如，下面代码中增加活跃玩家的代码：

@team = Team.find(1)
if @team.drafted_players.increment <= @team.max_players
  # do stuff
  @team.team_players.create!(:player_id => 221)
  @team.active_players.increment
else
  # reset counter state
  @team.drafted_players.decrement
end

An atomic block gives you a cleaner way to do the above. Exceptions or returning nil will rewind the counter back to its previous state:

使用原子块可以更加简洁的处理上述情况。异常或返回为 nil 会将计数器回滚到先前的状态：

@team.drafted_players.increment do |val|
  raise Team::TeamFullError if val > @team.max_players  # rewind
  @team.team_players.create!(:player_id => 221)
  @team.active_players.increment
end

Here's a similar approach, using an if block (failure rewinds counter):

下面有个类似的方法，使用了 if 块来在失效时回滚计数器：

@team.drafted_players.increment do |val|
  if val <= @team.max_players
    @team.team_players.create!(:player_id => 221)
    @team.active_players.increment
  end
end

Class methods work too, using the familiar ActiveRecord counter syntax:

类方法使用了类似 ActiveRecord 的计数语法，来保证原子递增：

Team.increment_counter :drafted_players, team_id
Team.decrement_counter :drafted_players, team_id, 2
Team.increment_counter :total_online_players  # no ID on global counter

Class-level atomic blocks can also be used. This may save a DB fetch, if you have a record ID and don't need any other attributes from the DB table:

类层次的原子块也能很有用。如果有一条记录 ID，并且不需要从数据获取其他的属性，这将节省从 DB 中的读取数据：

Team.increment_counter(:drafted_players, team_id) do |val|
  TeamPitcher.create!(:team_id => team_id, :pitcher_id => 181)
  Team.increment_counter(:active_players, team_id)
end

Locks

Locks work similarly. On completion or exception the lock is released:

锁的工作机制很相似，在完成或异常发生时，锁将会被释放：

class Team < ActiveRecord::Base
  lock :reorder # 申明一个锁
end

@team.reorder_lock.lock do
  @team.reorder_all_players
end

类层次的锁，概念相似：

Team.obtain_lock(:reorder, team_id) do
  Team.reorder_all_players(team_id)
end

Lock expiration. Sometimes you want to make sure your locks are cleaned up should the unthinkable happen (server failure). You can set lock expirations to handle this. Expired locks are released by the next process to attempt lock. Just make sure you expiration value is sufficiently large compared to your expected lock time.

锁过期失效。有时，需要确保在发生不可预测的事情 (服务器故障) 时，锁会自动的清除。这可以通过设置锁的过期。失效的锁将会在下一个进程尝试锁时，自动释放。确保失效值大于你所期待的锁的时间。

class Team < ActiveRecord::Base
  lock :reorder, :expiration => 15.minutes
end

Keep in mind that true locks serialize your entire application at that point. As such, atomic counters are strongly preferred.

谨记，锁会在某个点序列化整个应用程序。所以，更加推荐原子操作。

过期 (Expiration)

Use :expiration and :expireat options to set default expiration.

可以使用:expiration和:expireat来设置默认的过期时间：

value :value_with_expiration, :expiration => 1.hour
value :value_with_expireat, :expireat => Time.now + 1.hour

作者 Author

ubuntu 下 rvm 在 oh-my-zsh 下出现了的问题

xiajian — Fri, 22 May 2015 17:17:46 +0800

几天前，本身朝圣的心态，试用了 zsh，确实相当的强大，但是，也发现了一些问题，主要和 rvm 相关的。

首先是，rvm 补全时，比如rvm cur<TAB>时会出现这样：

rvm curWarning! PATH is not properly set up, '/home/xiajian/.rvm/gems/ruby-1.9.3-p551@tophold/bin' is not at first place,
         usually this is caused by shell initialization files - check them for 'PATH=...' entries,
         it might also help to re-add RVM to your dotfiles: 'rvm get stable --auto-dotfiles',
         to fix temporarily in this shell session run: 'rvm use ruby-1.9.3-p551@tophold'.
current 
Warning! PATH is not properly set up, '/home/xiajian/.rvm/gems/ruby-1.9.3-p551@tophold/bin' is not at first place,
         usually this is caused by shell initialization files - check them for 'PATH=...' entries,
         it might also help to re-add RVM to your dotfiles: 'rvm get stable --auto-dotfiles',
         to fix temporarily in this shell session run: 'rvm use ruby-1.9.3-p551@tophold'.
ruby-1.9.3-p551@tophold

这个，还可以忍受，难以忍受的是，设定的.ruby-gemset和.ruby-version时而能工作，时而不能工作。比如，使用rvm use 1.9.3@tophold --default设定了默认的环境。

然后，尝试一下 ruby 2.1.2 和 rails 4，锁定 ruby 和 gemset，然后 bundle 成功了，重开了一个 tab 页，rvm 的环境又变回去了。请问，各位大神，有遇到这个问题吗？？

学习 Vagrant

xiajian — Tue, 19 May 2015 18:14:46 +0800

前言

最早的时候，是在某学弟的说说中看到 vagrant。github 上搜了一下，发现 star 数还挺多的。随后的岁月里，常常能看到这个名词，今天研究一下。

不知道这到底属于那个节点，姑且归类为部署吧。

vagrant 是什么

Vagrant 提供了基于企业级标准技术的易配置、可重复、可移植的工作环境，从而最大化团队的生产力和灵活性。

Vagrant 可构建在由 VirtualBox，VMware，AWS 以及其他提供商提供的机器上，并且可以使用 shell 脚本，Chef，Puppet 等配置管理工具。

vagrant 的特点：

将配置和依赖隔离在一次性和一致性的环境中
使用简单，只需Vagrantfile和vagrant up，适用人群广 (开发者，运维人员，设计师)

vagrant 其实就是封装了的 Virtualbox 的 API 的 ruby DSL，抽象和简化了某些操作，用一个命令以及配置文件，而不是一堆命令去管理和使用 vm。

安装

先决条件：安装virtualbox - 安装的 virtualbox 版本为4.3.20r96996(vboxmanage -v)。

安装使用 installer，用 RubyGems 安装问题多多，依赖巨复杂，vagrant 安装的版本是 1.7.2 (vagrant version)

注：哪天，小爷我不开心了，要将 vagrant 删掉，只要删除/opt/vagrant目录和/usr/bin/vagrant文件。用户数据存放在~/.vagrant.d中，下次重装可直接复用。

使用

起步

按如下的命令列表，即可启动进入一个虚拟机中：

mkdir test && cd test
vagrant box add base http://files.vagrantup.com/lucid32.box  # 这里的模式是 vagrant box add {title} {url}
vagrant init base # 初始化一个box为base的Vagrantfile，默认box就是base
vagrant up        # 启动虚拟机
vagrant ssh       # ssh到虚拟机环境中

boxes

vagrant 强大之处，在于使用镜像 (image) 快速创建 (克隆) 虚拟机。vagrant 中将镜像称作 box，创建Vagrantfile之后，最重要的就是指定环境所用的 box。

box 的子命令如下：

add - 添加新的 box
list - 列出所有的 box
outdated - 检查是否最新
remove - 删除 box
repackage - 重新打包 box
update - 更新特定 box

一些镜像 (box) 的地址是：

http://www.vagrantbox.es/ - 可以看到各种各样的 vm provider 的 box
https://atlas.hashicorp.com/boxes/search - 官方支持的公共可用的 box

若是从http://www.vagrantbox.es/直接下载镜像，则需要运行如下的命令：

mkdir test2 && cd test2
wget https://github.com/jose-lpa/packer-ubuntu_14.04/releases/download/v2.0/ubuntu-14.04.box
vagrant init ubuntu-14.04.box  # ubuntu-14.04.box为已下载的某镜像文件
vagrant up
vagrant ssh

备注：起初看到启动 vm 时，可以通过 ssh 进行连接的，尝试ssh vagrant@127.0.0.1:2200 ，一直 timeout。看了官方文档后，才知道原来使用vagrant ssh命令。

注意：不要在虚拟机中运行rm -rf /，因为虚拟机与宿主机器存在共享目录/vagrant。

同步目录

同步目录：貌似和共享文件夹又有所不同，vagrant 会自动 sync 文件，所以，这句话表示存在两个文件还是一个文件。不过，同步和共享肯定是不同的。

自动配置

Vagrant 内建了对自动配置的支持，其可以在vagrant up时，自动安装软件。从而使其客机虚拟机可以重复创建且随时可用。

举个例子，比如安装 apache:

首先，在 Vagrantfile 的相同目录中，保存名为bootstrap.sh的文件：

#!/usr/bin/env bash

apt-get update
apt-get install -y apache2
if ! [ -L /var/www ]; then
  rm -rf /var/www
  ln -fs /vagrant /var/www
fi

然后，在 Vagrantfile 写入如下的配置：config.vm.provision :shell, path: "bootstrap.sh"

或者直接写在 Vagrantfile 文件中：

config.vm.provision "shell", inline: <<-SHELL
  sudo apt-get update
  sudo apt-get install -y apache2
  if ! [ -L /var/www ]; then
    rm -rf /var/www
    ln -fs /vagrant /var/www
  fi
SHELL

网络

网络主要就是端口映射和内网 IP 的设置，端口映射的配置为：

config.vm.network :forwarded_port, host: 4567, guest: 80

共享

共享分发开发环境，需要一个免费的 HashiCorp's Atlas 帐号。使用命令如下：

vagrant login
vagrant share

注：感觉 vagrant 所做的，其实和 docker hub 很相似，都是基于 image 的仓库。

Providers

Vagrant 支持很多不同后端 vm 后端，除了 VirtualBox，还有 VMware, AWS, Docker 等。这些 provider 本身，可以无缝切换。

命令行接口

vagrant 提供了丰富操作的命令，其中，常用的一些如下：

vagrant up       # 启动虚拟机，会执行相应的自动配置
vagrant halt     # 关机
vagrant reload   # 重新启动，主要用于重新载入配置文件
vagrant suspend  # 挂起当前虚拟机
vagrant resume   # 恢复被挂起的vm
vagrant box list # 列出所有box列表
vagrant box remove {basename}
vagrant destroy  # 停止当前正在运行的虚拟机并销毁所有创建的资源
vagrant package  # 把当前的运行的虚拟机环境进行打包，可用于分发开发环境
vagrant plugin   # 安装卸载插件 
vagrant provision  # 设置基本的环境，进一步设置可以使用Chef/Puppet进行搭建
vagrant ssh-config # 输出ssh连接的一些信息
vagrant status     # 获取虚拟机状态
vagrant version    # 获取vagrant的版本

除了上面的那些命令，还有 login、rdp、share、global-status 等等，详细参考 vagrant -h。

剩下的大部分需要的学习的部分都在了解如何配置 Vagrantfile 文件。

vagrant 的用处：单机模拟多台机器，从而测试分布式的集群环境。Vagrantfile 中可以定义 vm 的角色，也可vagrant ssh {role-name}到特定的机器上去。

vagrant 的相关配置

vagrantfile 相关的配置涉及 vm、ssh、winrm、vagrant、box、network、同步目录，多机器配置，虚拟技术提供方，插件 (似乎提供不少插件) 以及推送 (Push)。

简单的配置介绍如下：

config.vm.box = "base"      # vm的box的基，默认为base
config.vm.customize ["modifyvm", :id, "--name", "gogojimmy", "--memory", "512"]  # 配置vm的各种参数
config.vm.host_name = "xxx" # 配置主机名，很重要的标识
config.vm.network           # 两种桥接方式，私有和公共

同步目录：貌似和共享文件夹又有所不同，vagrant 会自动 sync 文件，所以，这句话表示存在两个文件还是一个文件。

最为强大的是多虚拟机的系统设置，只需在同一Vagrantfile中定义不同的用户角色即可：

config.vm.define :app do |app_config|
  app_config.vm.host_name = "app"
  app_config.vm.network "private_network", ip: "33.33.13.10"
end

config.vm.define :db do |db_config|
  db_config.vm.host_name = "db"
  db_config.vm.network "private_network", ip: "33.33.13.11"
  db_config.vm.provider "virtualbox" do |vb|
    vb.memory = "512"
  end
end

config.vm.define :cache do |cache_config|
  cache_config.vm.host_name = "cache"
  cache_config.vm.network "private_network", ip: "33.33.13.12"
end

通过上面的配置，然后运行vagrant up，分分钟就可以启动 3 台虚拟机了。具体输出如下：

Bringing machine 'app' up with 'virtualbox' provider...
Bringing machine 'db' up with 'virtualbox' provider...
Bringing machine 'cache' up with 'virtualbox' provider...
==> app: Clearing any previously set forwarded ports...
==> app: Fixed port collision for 22 => 2222. Now on port 2200.
==> app: Clearing any previously set network interfaces...
==> app: Preparing network interfaces based on configuration...
    app: Adapter 1: nat
    app: Adapter 2: hostonly
==> app: Forwarding ports...
    app: 22 => 2200 (adapter 1)
==> app: Booting VM...
==> app: Waiting for machine to boot. This may take a few minutes...
    app: SSH address: 127.0.0.1:2200
    app: SSH username: vagrant
    app: SSH auth method: private key
    app: Warning: Connection timeout. Retrying...
==> app: Machine booted and ready!
==> app: Checking for guest additions in VM...
    app: The guest additions on this VM do not match the installed version of
    app: VirtualBox! In most cases this is fine, but in rare cases it can
    app: prevent things such as shared folders from working properly. If you see
    app: shared folder errors, please make sure the guest additions within the
    app: virtual machine match the version of VirtualBox you have installed on
    app: your host and reload your VM.
    app: 
    app: Guest Additions Version: 4.2.0
    app: VirtualBox Version: 4.3
==> app: Setting hostname...
==> app: Configuring and enabling network interfaces...
==> app: Mounting shared folders...
    app: /vagrant => /home/xiajian/works/test/vargant
==> app: Machine already provisioned. Run `vagrant provision` or use the `--provision`
==> app: to force provisioning. Provisioners marked to run always will still run.
  。。省略DB和Cache的启动。。。

备注：不同版本的 vagrant 之间的配置可能有所区别，具体的以当前生成的 Vagrantfile 中配置描述的为准。 vagrant reload只能对已有的虚拟机进行配置的重新载入，对于未创建的虚拟机则不作处理。所以，虚拟机的启动，主要还是靠vagrant up命令。

此外，virtualbox 仅仅是 vagrant 的一个虚拟机提供商，Docker 和 VMWare 也是 vagrant 的 provider。

vagrant 文档提供了翔实的信息，更多可参考https://docs.vagrantup.com/v2/ 。

virtualbox

虚拟化的好处：

可同时运行多个操作系统
软件安装更容易 - 将复杂的步骤打包到虚拟机中
测试和容灾恢复 - 快照功能、保存虚拟机特定状态，云主机有自动打快照的功能
基础设施的整合 - 充分利用物理机器的性能

术语: Host OS(宿主 os), Guest OS(支持任何 X86 的系统), 虚拟机 (VirtualBox 为 Guest OS 创建的特定环境，VirtualBox 默认将虚拟机看作一组参数 - 决定了虚拟机的行为), 客机增强件 (安装在虚拟机中，提高客机性能和额外的功能支持)

Virtualbox 的功能概览：

可移植性，2 类虚拟机管理程序，相对直接运行在裸机上虚拟机 (一类 vm mangement)。开放虚拟化格式 OVF。
硬件虚拟化不是必备条件 - 处理器可支持虚拟化技术
客机增强套件：共享文件夹，无缝窗口，3D 虚拟化。
硬件支持：SMP,USB, 硬件兼容性，PXE 等
多代可分支快照
架构整洁、结构模块化，存在 SDK 接口 - vagrant 所依赖的
远程桌面显示：VRDE 之类

VirtualBox 提供了不少命令行工具：

VBox
VBoxAutostart
VBoxBalloonCtrl
VBoxHeadless
VBoxManage 是 Virtualbox 的命令行接口，其支持比图形界面更多的功能，可展现虚拟引擎的所有功能。
VBoxSDL
VBoxTunctl
VBoxVRDP

备注：上面的这些命令也存在小写字母版的，果然，要大写什么的，太不方便了。

需要编译并加载 vboxdrv 内核模块，VirtualBox 应用程序通过 Unix 本地套接字与后台程序通信。

两种镜像文件：动态扩展的镜像文件、固定大小镜像文件。

更多相关技术，可以参考 VirtualBox 提供的相关的文档：https://www.virtualbox.org/wiki/Documentation

虚拟化相关的技术：XEN, KVM(OpenStack 利用)，Hypervisor，基于 LXC 的 Docker。虚拟化的技术，需要对 OS 的理解加深。

后记

原本是为了装 qq，才去装 virtualbox 和 XP 的镜像系统，结果用了一段时间后，发现体验和感觉都相当的不错。这让我意识到虚拟环境的有用和高效之处。

阅读了一下 Virtualbox 的文档之后，发现 Virtualbox 有提供 API 和 SDK 的接口。这样就很好理解 vagrant 的开发的基础。此外，偶然发现，vagrant 的作者在 11 年的时候，曾开发过一个virtualbox的 gem。此外，Virtualbox 本身以依赖其他的一些 GNU 的虚拟机的代码，比如 bochs。

参考文献

Sinatra 中文文档

xiajian — Tue, 19 May 2015 18:01:23 +0800

注：本文档是英文版的翻译，结合http://www.sinatrarb.com/intro-zh.html，以及自己更新翻译了原中文文档一部分。如有不一致的地方，请以英文版为准。

注：绝大部分翻译归原翻译者 (http://www.sinatrarb.com/intro-zh.html) 所有，其中参杂了部分个人的观点。

英文文档地址：http://www.sinatrarb.com/intro.html 中文文档地址：http://www.sinatrarb.com/intro-zh.html

简介

Sinatra 是一个基于 Ruby 语言的 DSL（领域专属语言），可以轻松、快速的创建 web 应用。

# myapp.rb
require 'sinatra'

get '/' do
  'Hello world!'
end

安装 gem，然后运行：

gem install sinatra
ruby myapp.rb

在该地址查看： http://localhost:4567

这个时候访问地址将绑定到 127.0.0.1 和 localhost，如果使用 vagrant 进行开发，访问会失败，此时就需要进行 ip 绑定了：

关于 vagrant，网上资料一坨，不介意的话，可以参考我自己写的学习 vagrant

备注：第一次执行 sinatra 程序的时候，感觉有点奇怪，感觉像是在进行冒烟测试，难道和自己的执行的程序有关。

安装 Sintra 后，最好再运行gem install thin安装 Thin。这样，Sinatra 会优先选择 Thin 作为服务器。找不到 thin 时，使用 WEBRick 作为服务器。

路由 (route)

在 Sinatra 中，一个路由分为两部分：HTTP 方法 (GET, POST 等) 和 URL 匹配范式 (pattern)。每个路由都有一个要执行的代码块：

get '/' do
  .. 显示内容 ..
end

post '/' do
  .. 创建内容 ..
end

put '/' do
  .. 更新内容 ..
end

delete '/' do
  .. 删除内容 ..
end

options '/' do
  .. 显示命令列表 ..
end

link '/' do
  .. 建立某种联系 ..
end

unlink '/' do
  .. 解除某种联系 ..
end

路由按照它们被定义的顺序进行匹配，这一点和 Rails 中的 routes 文件的定义类似。第一个与请求匹配的路由会被调用。

路由范式 (pattern) 可以包括具名参数，参数的值可通过params['name']哈希表获得：

get '/hello/:name' do
  # 匹配 "GET /hello/foo" 和 "GET /hello/bar"
  # params[:name] 的值是 'foo' 或者 'bar'
  "Hello #{params[:name]}!"
end

也可以通过代码块参数获得具名参数：

get '/hello/:name' do |n|
  # 匹配"GET /hello/foo" 和 "GET /hello/bar"
  # params[:name] 的值是 'foo' 或者 'bar'
  # n 中存储了 params['name']
  "Hello #{n}!"
end

路由范式 (pattern) 也可以包含通配符参数 (splat parameter)，可以通过params[:splat]数组获得。

get '/say/*/to/*' do
  # 匹配 /say/hello/to/world
  params[:splat] # => ["hello", "world"]
end

get '/download/*.*' do
  # 匹配 /download/path/to/file.xml
  params[:splat] # => ["path/to/file", "xml"]
end

通过正则表达式匹配的路由：

get %r{/hello/([\w]+)} do
  "Hello, #{params[:captures].first}!"
end

%r{}表示字符串是正则表达式，这里需要注意的就是，将正则表达式匹配的变量捕获到params['captures']中了。

或者使用块参数：

get %r{/hello/([\w]+)} do |c|
  "Hello, #{c}!"
end

路由范式也可包含可选的参数：

get '/posts.?:format?' do
  # matches "GET /posts" and any extension "GET /posts.json", "GET /posts.xml" etc.
  # 匹配 "GET /posts" 以及带任何扩展名的  "GET /posts.json" , "GET /posts.xml" 等
end

路由也可使用查询参数：

get '/posts' do
  # matches "GET /posts?title=foo&author=bar"
  # 匹配  "GET /posts?title=foo&author=bar"
  title = params['title']
  author = params['author']
  # 使用title和 author 变量，对于 /posts 路由，查询参数是可选的
end

By the way, unless you disable the path traversal attack protection (see below), the request path might be modified before matching against your routes.

顺便说一下，除非想要禁用路径遍历攻击保护 (path traversal attack protection) , 请求路径可在匹配路由之前修改。

条件

路由也可以包含多样的匹配条件，比如 user agent(用户代理，比如浏览器就是一种用户代理)：

get '/foo', :agent => /Songbird (\d\.\d)[\d\/]*?/ do
  "你正在使用Songbird，版本是 #{params[:agent][0]}"  # :agent 代表了用户代理相关的变量，版本的信息相当的全面
end

get '/foo' do
  # 匹配除Songbird以外的浏览器
end

其他可选的条件是 host_name 和 provides：

get '/', :host_name => /^admin\./ do
  "管理员区域，无权进入！"  # host_name 表示的是主机用户的名字
end

get '/', :provides => 'html' do
  haml :index
end

get '/', :provides => ['rss', 'atom', 'xml'] do
  builder :feed
end

provides 查找请求的 Accpet 头部信息

你也可以使用set方法自定义条件：

set(:probability) { |value| condition { rand <= value } }

get '/win_a_car', :probability => 0.1 do
  "You won!"
end

get '/win_a_car' do
  "Sorry, you lost."
end

如果某条件需要多个值作为输入，可以使用通配符参数 :

set(:auth) do |*roles|   # <- notice the splat here
  condition do
    unless logged_in? && roles.any? {|role| current_user.in_role? role }
      redirect "/login/", 303
    end
  end
end

get "/my/account/", :auth => [:user, :admin] do
  "Your Account Details"
end

get "/only/admin/", :auth => :admin do
  "Only admins are allowed here!"
end

返回值

路由代码块的返回值至少决定了返回给 HTTP 客户端的响应体，或者至少决定了在Rack堆栈中的下一个中间件。大多数情况下，将是一个字符串，就像上面的例子中的一样。但是其他值也是可以接受的。

你可以返回任何对象，或者是一个合理的 Rack 响应，Rack body 对象或者 HTTP 状态码：

带有如下三个元素数组： [status (Fixnum), headers (Hash), response body (responds to #each)]
带有两个元素的数组： [status (Fixnum), response body (responds to #each)]
响应each方法，并且对于给定的块接受字符串参数的 ruby 对象
表示状态码的整数

那样，我们可以轻松的实现例如流式传输的例子：

class Stream
  def each
    100.times { |i| yield "#{i}\n" }
  end
end

get('/') { Stream.new }

可以使用stream辅助函数来减少 boiler plate(？？) , 并在路径中内嵌流逻辑。

所以，学习技术果然还是要基础牢固，从底层开始，自下而上的构建技术体系。所以，Rack 到底是什么，其本身是如何模块化的 web 编程，很多事情都需要从概念上去把握。

自定义路由匹配器

如上显示，Sinatra 内置了对于使用字符串和正则表达式作为路由匹配的支持。但是，它并没有只限于此。你可以非常容易地定义你自己的匹配器：

class AllButPattern
  Match = Struct.new(:captures)  # :captures键中存放的就是捕获的匹配文本

  def initialize(except)
    @except   = except
    @captures = Match.new([])
  end

  def match(str)
    @captures unless @except === str
  end
end

def all_but(pattern)
  AllButPattern.new(pattern)
end

get all_but("/index") do
  # ...
end

上面的例子可能太繁琐了，因为它也可以用更简单的方式表述：

get // do
  pass if request.path_info == "/index"
  # ...
end

或者，使用反向查找模式：

get %r{^(?!/index$)} do
  # ...
end

静态文件

静态文件是从 ./public 目录提供服务。你可以通过设置:public_folder 选项设定一个不同的位置：

set :public_folder, File.dirname(FILE) + '/static'

请注意 public 目录名并没有被包含在 URL 之中。文件./public/css/style.css是通过http://example.com/css/style.css地址访问的。

视图 / 模板

模板被假定直接位于./views目录。使用不同的视图目录，可以这样设置：

set :views, File.dirname(FILE) + '/templates'

每个模板语言都可以通过其自身的渲染方法 (比如：erb,haml) 来渲染，这些方法可以简单的返回字符串。

get '/' do
  erb :index
end

get '/index' do
  code = "<%= Time.now %>"
  erb code
end

模板可以接受第二个参数，即选项 hash:

get '/' do
  erb :index, :layout => :post
end

上面的代码，将会将views/index.erb渲染到views/post.erb(布局模板) 文件中，默认的布局模板是views/layout.erb。

任何 Sinatra 不理解选项都将被传递到模板引擎中。

get '/' do
  haml :index, :format => :html5
end

通过 set 选项，可以设置模板语言的通用选项：

set :haml, :format => :html5 # html5是新技术，使用新技术有风险也有挑战

get '/' do
  haml :index
end

传递给 render 方法的选项可以通过set方法进行设置，常见的选项如下：

locals: 列出传递给文档的局部变量 (locals)，用来处理部分视图。例如：erb "<%= foo %>", :locals => {:foo => "bar"}
default_encoding: 不确定时使用的字符编码，默认为 settings.default_encoding.
views: 加载模板的视图文件夹，默认为:settings.views.
layout: 是否使用布局 (true 或者 false). 如果为符号，表明所使用的模板，例如：erb :index, :layout => !request.xhr?(这个实例不错，判断是否是 xhr，从而确定是否使用布局)
content_type: 模板所生成的内容类型 (json,html,js 之类), 模板依赖模板语言
scope: 渲染模板所在的域。默认为应用程序实例。如果改变值，实例变量和辅助方法都将不在可得获取
layout_engine: 模板应用用来渲染布局，这对那些不支持布局的语言非常有用。默认使用模板引擎，例如：set :rdoc , :layout_engine => :erb
layout_options: 仅用来渲染布局的特定选项，例如：set :rdoc, :layout_options => { :views => 'views/layouts' }

Sinatra 总是假设模板位于/views目录，可以set :views, settings.root + '/templates'设置不同的视图文件。

请记住一件非常重要的事情，你只可以通过符号引用模板，即使它们在子目录下（在这种情况下，使用 :'subdir/template'）。你必须使用一个符号，因为渲染方法会直接地渲染任何传入的字符串。

字面值模板

get '/' do
  haml '%div.title Hello World'
end

上述代码将会渲染模板字符串。

可得到的模板语言

有些语言存在多个实现，为了指定使用的那种实现 (或者为了线程安全)，可以简单的提前require:

Haml 模板

Dependency: haml
File Extension: .haml
Example: haml :index, :format => :html5

需要引入 haml gem/library以渲染 HAML 模板：

# 你需要在你的应用中引入 haml
require 'haml'

get '/' do
  haml :index
end

Erb 模板

Dependency: erubis or erb (included in Ruby)
File Extensions: .erb, .rhtml or .erubis (Erubis only)
Example: erb :index

Builder 模板

Dependency: builder
File Extension: .builder
Example: builder { |xml| xml.em "hi" }

builder 接受内联模板的代码块。

Nokogiri 模板

Dependency: nokogiri
File Extension: .nokogiri
Example: nokogiri { |xml| xml.em "hi" }

同样接受内联模板的代码块，看起来也是用来构建 xml 的应用的。

Sass 模板

Dependency: sass
File Extension: .sass
Example: sass :stylesheet, :style => :expanded

Scss 模板

Dependency: sass
File Extension: .scss
Example: scss :stylesheet, :style => :expanded

Scss 的选项可以通过 Sinatra 选项全局设定，参考选项和配置, 也可以在个体的基础上覆盖。

Less 模板

Dependency: less
File Extension: .less
Example: less :stylesheet

Liquid 模板

Dependency liquid
File Extension .liquid
Example liquid :index, :locals => { :key => 'value' }

Liquid 模板中逻辑非常的弱，所以，其强制将逻辑放置到控制器中，从而严格遵寻 MVC 框架。Liquid 模板中不用调用 Ruby 的方法，总是需要将局部变量传递给模板。

Github Pages 就是利用 Liquid 的模板来设置页面布局，从而保证了页面的安全性。简单说，给你把软刀，能用且安全。

Markdown Templates

Dependency Anyone of: RDiscount, RedCarpet, BlueCloth, kramdown, maruku
File Extensions .markdown, .mkd and .md
Example markdown :index, :layout_engine => :erb

既不可能在 Markdown 中调用方法，也不能传递局部变量给它。通常用来组合其他的渲染引擎 (比如，jekyll 就是组合了 Liquid 和 Markdown。

erb :overview, :locals => { :text => markdown(:introduction) }

Note that you may also call the markdown method from within other templates:

注意，可以从其他模板中调用markdown方法：

%h1 Hello From Haml!
%p= markdown(:greetings)

既然你不能在 Markdown 中调用 Ruby，你不能使用 Markdown 编写的布局。不过，使用其他渲染引擎作为模版的布局是可能的，通过传递:layout_engine 选项：

get '/' do
  markdown :index, :layout_engine => :erb
end

这将会调用 ./views/index.md 并使用 ./views/layout.erb 作为布局。

请记住你可以全局设定这个选项：

set :markdown, :layout_engine => :haml, :layout => :post

get '/' do
  markdown :index
end

这将会调用 ./views/index.markdown (和任何其他的 Markdown 模版) 并使用 ./views/post.haml 作为布局。

也可用 BlueCloth 而不是 RDiscount 来解析 Markdown 文件：

require 'bluecloth'

Tilt.register 'markdown', BlueClothTemplate
Tilt.register 'mkd',      BlueClothTemplate
Tilt.register 'md',       BlueClothTemplate

get '/' do
  markdown :index
end

CoffeeScript 模板

Dependency CoffeeScript以及执行 js 的方式
File Extension .coffee
Example coffee :index

参考https://github.com/josh/ruby-coffee-script 获取更新的选项，CoffeeScript 模版的使用样例：

# 需要在你的应用中引入coffee-script
require 'coffee-script'

get '/application.js' do
  coffee :application #调用的是 ./views/application.coffee
end

Textile 模板 : RedCloth

RDoc 模板 : [RDoc]

以及其他诸多模板:AsciiDoc ,Radius ,Markaby ,RABL ,Slim ,Creole ,MediaWiki ,CoffeeScript ,Stylus ,Yajl ,WLang。不再一一列举。

注：老版的中文翻译，对模板部分介绍的比较详细，这里摘录如下：

Haml 模板

需要引入 haml gem/library以填充 HAML 模板：

# 你需要在你的应用中引入 haml
require 'haml'

get '/' do
  haml :index
end

填充 ./views/index.haml。

Haml 的选项可以通过 Sinatra 的配置全局设定，参见选项和配置，也可以个别的被覆盖。

set :haml, {:format => :html5 } # 默认的Haml输出格式是 :xhtml

get '/' do
  haml :index, :haml_options => {:format => :html4 } # 被覆盖，变成:html4
end

Erb 模板

# 你需要在你的应用中引入 erb
require 'erb'

get '/' do
  erb :index
end

这里调用的是 ./views/index.erb

Erubis

需要引入 erubis gem/library以填充 erubis 模板：

# 你需要在你的应用中引入 erubis
require 'erubis'

get '/' do
  erubis :index
end

这里调用的是 ./views/index.erubis

使用 Erubis 代替 Erb 也是可能的：

require 'erubis'
Tilt.register :erb, Tilt[:erubis]

get '/' do
  erb :index
end

使用 Erubis 来填充 ./views/index.erb。

Builder 模板

需要引入 builder gem/library 以填充 builder templates：

# 需要在你的应用中引入builder
require 'builder'

get '/' do
  builder :index
end

这里调用的是 ./views/index.builder。

Nokogiri 模板

需要引入 nokogiri gem/library 以填充 nokogiri 模板：

# 需要在你的应用中引入 nokogiri
require 'nokogiri'

get '/' do
  nokogiri :index
end

这里调用的是 ./views/index.nokogiri。

Sass 模板

需要引入 haml 或者 sass gem/library 以填充 Sass 模板：

# 需要在你的应用中引入 haml 或者 sass
require 'sass'

get '/stylesheet.css' do
  sass :stylesheet
end

这里调用的是 ./views/stylesheet.sass。

Sass 的选项可以通过 Sinatra 选项全局设定，参考选项和配置（英文）, 也可以在个体的基础上覆盖。

set :sass, {:style => :compact } # 默认的 Sass 样式是 :nested

get '/stylesheet.css' do
  sass :stylesheet, :style => :expanded # 覆盖
end

Scss 模板

需要引入 haml 或者 sass gem/library 来填充 Scss templates：

# 需要在你的应用中引入 haml 或者 sass
require 'sass'

get '/stylesheet.css' do
  scss :stylesheet
end

这里调用的是 ./views/stylesheet.scss。

Scss 的选项可以通过 Sinatra 选项全局设定，参考选项和配置（英文）, 也可以在个体的基础上覆盖。

set :scss, :style => :compact # default Scss style is :nested

get '/stylesheet.css' do
  scss :stylesheet, :style => :expanded # overridden
end

Less 模板

需要引入 less gem/library 以填充 Less 模板：

# 需要在你的应用中引入 less
require 'less'

get '/stylesheet.css' do
  less :stylesheet
end

这里调用的是 ./views/stylesheet.less。

Liquid 模板

需要引入 liquid gem/library 来填充 Liquid 模板：

# 需要在你的应用中引入 liquid
require 'liquid'

get '/' do
  liquid :index
end

这里调用的是 ./views/index.liquid。

因为你不能在 Liquid 模板中调用 Ruby 方法 (除了 yield) ，你几乎总是需要传递 locals 给它：

liquid :index, :locals => { :key => 'value' }

Markdown 模板

需要引入 rdiscount gem/library 以填充 Markdown 模板：

# 需要在你的应用中引入rdiscount
require "rdiscount"

get '/' do
  markdown :index
end

这里调用的是 ./views/index.markdown (md 和 mkd 也是合理的文件扩展名)。

在 markdown 中是不可以调用方法的，也不可以传递 locals 给它。你因此一般会结合其他的填充引擎来使用它：

erb :overview, :locals => { :text => markdown(:introduction) }

请注意你也可以从其他模板中调用 markdown 方法：

%h1 Hello From Haml!
%p= markdown(:greetings)

既然你不能在 Markdown 中调用 Ruby，你不能使用 Markdown 编写的布局。不过，使用其他填充引擎作为模版的布局是可能的，通过传递:layout_engine选项：

get '/' do
  markdown :index, :layout_engine => :erb
end

这将会调用 ./views/index.md 并使用 ./views/layout.erb 作为布局。

请记住你可以全局设定这个选项：

set :markdown, :layout_engine => :haml, :layout => :post

get '/' do
  markdown :index
end

这将会调用 ./views/index.markdown (和任何其他的 Markdown 模版) 并使用 ./views/post.haml 作为布局。

也可能使用 BlueCloth 而不是 RDiscount 来解析 Markdown 文件：

require 'bluecloth'

Tilt.register 'markdown', BlueClothTemplate
Tilt.register 'mkd',      BlueClothTemplate
Tilt.register 'md',       BlueClothTemplate

get '/' do
  markdown :index
end

使用 BlueCloth 来填充 ./views/index.md 。

Textile 模板

需要引入 RedCloth gem/library 以填充 Textile 模板：

# 在你的应用中引入redcloth
require "redcloth"

get '/' do
  textile :index
end

这里调用的是 ./views/index.textile。

在 textile 中是不可以调用方法的，也不可以传递 locals 给它。你因此一般会结合其他的填充引擎来使用它：

erb :overview, :locals => { :text => textile(:introduction) }

请注意你也可以从其他模板中调用textile方法：

%h1 Hello From Haml!
%p= textile(:greetings)

既然你不能在 Textile 中调用 Ruby，你不能使用 Textile 编写的布局。不过，使用其他填充引擎作为模版的布局是可能的，通过传递:layout_engine选项：

get '/' do
  textile :index, :layout_engine => :erb
end

这将会填充 ./views/index.textile 并使用 ./views/layout.erb 作为布局。

请记住你可以全局设定这个选项：

set :textile, :layout_engine => :haml, :layout => :post

get '/' do
  textile :index
end

这将会调用 ./views/index.textile (和任何其他的 Textile 模版) 并使用 ./views/post.haml 作为布局。

RDoc 模板

需要引入 RDoc gem/library 以填充 RDoc 模板：

# 需要在你的应用中引入rdoc/markup/to_html
require "rdoc"
require "rdoc/markup/to_html"

get '/' do
  rdoc :index
end

这里调用的是 ./views/index.rdoc。

在 rdoc 中是不可以调用方法的，也不可以传递 locals 给它。你因此一般会结合其他的填充引擎来使用它：

erb :overview, :locals => { :text => rdoc(:introduction) }

请注意你也可以从其他模板中调用rdoc方法：

%h1 Hello From Haml!
%p= rdoc(:greetings)

既然你不能在 RDoc 中调用 Ruby，你不能使用 RDoc 编写的布局。不过，使用其他填充引擎作为模版的布局是可能的，通过传递:layout_engine选项：

get '/' do
  rdoc :index, :layout_engine => :erb
end

这将会调用 ./views/index.rdoc 并使用 ./views/layout.erb 作为布局。

请记住你可以全局设定这个选项：

set :rdoc, :layout_engine => :haml, :layout => :post

get '/' do
  rdoc :index
end

这将会调用 ./views/index.rdoc (和任何其他的 RDoc 模版) 并使用 ./views/post.haml 作为布局。

Radius 模板

需要引入 radius gem/library 以填充 Radius 模板：

# 需要在你的应用中引入radius
require 'radius'

get '/' do
  radius :index
end

这里调用的是 ./views/index.radius。

因为你不能在 Radius 模板中调用 Ruby 方法 (除了 yield) ，你几乎总是需要传递 locals 给它：

radius :index, :locals => { :key => 'value' }

Markaby 模板

需要引入markaby gem/library以填充Markaby模板：

#需要在你的应用中引入 markaby
require 'markaby'

get '/' do
  markaby :index
end

这里调用的是 ./views/index.mab。

你也可以使用嵌入的 Markaby:

get '/' do
  markaby { h1 "Welcome!" }
end

Slim 模板

需要引入 slim gem/library 来填充 Slim 模板：

# 需要在你的应用中引入 slim
require 'slim'

get '/' do
  slim :index
end

这里调用的是 ./views/index.slim。

Creole 模板

需要引入 creole gem/library 来填充 Creole 模板：

# 需要在你的应用中引入 creole
require 'creole'

get '/' do
  creole :index
end

这里调用的是 ./views/index.creole。

CoffeeScript 模板

需要引入 coffee-script gem/library 并至少满足下面条件一项以执行 Javascript:

node (来自 Node.js) 在你的路径中
你正在运行 OSX
therubyracer gem/library

请察看github.com/josh/ruby-coffee-script 获取更新的选项。

现在你可以调用 CoffeeScript 模版了：

# 需要在你的应用中引入coffee-script
require 'coffee-script'

get '/application.js' do
  coffee :application
end

这里调用的是 ./views/application.coffee。

在模板中访问变量

模板和路由执行器在同样的上下文求值，在路由执行器中赋值的实例变量可以直接被模板访问。路由就是控制器 + 动作，这里免去了 Rails 中控制器和视图的分层 (避免的控制器到视图中对象的复制):

get '/:id' do
  @foo = Foo.find(params[:id])
  haml '%h1= @foo.name'
end

或者，显式地指定一个局部变量的哈希：

get '/:id' do
  foo = Foo.find(params[:id])
  haml '%h1= foo.name', :locals => { :foo => foo }
end

显示传递局部变量的典型的使用情况是在模板中渲染局部模板的方式来渲染。

yield 模板和嵌套布局

布局通常是包含了 yield 方法的模板。布局模板可以通过:template选项使用，也可用来渲染一个如下的块：

erb :post, :layout => false do
  erb :index
end

上述代码等价于erb :index, :layout => :post。

对于创建嵌套布局而言，传递块给渲染方法非常的有用：

erb :main_layout, :layout => false do
  erb :admin_layout do
    erb :user
  end
end

上述代码，等价于如下的代码：

erb :admin_layout, :layout => :main_layout do
  erb :user
end

当前，可以接受块的渲染方法有：erb, haml, liquid, slim , wlang 以及通用的 render 方法。

内联模板

模板可以在源文件的末尾定义：

require 'sinatra'

get '/' do
  haml :index
end

__END__

@@ layout
%html
  = yield

@@ index
%div.title Hello world!!!!!

注意：引入 sinatra 的源文件中定义的内联模板才能被自动载入。如果你在其他源文件中有内联模板，需要显式执行调用 enable :inline_templates。

具名模板

模板可以通过使用顶层template方法定义：

template :layout do
  "%html\n  =yield\n"
end

template :index do
  '%div.title Hello World!'
end

get '/' do
  haml :index
end

如果存在名为“layout”的模板，该模板会在每个模板渲染的时候被使用。你可以单独地通过传送 :layout => false 来禁用，或者通过 set :haml, :layout => false 来禁用他们。

get '/' do
  haml :index, :layout => !request.xhr?
end

关联文件扩展名

为了关联一个文件扩展名到一个模版引擎，使用 Tilt.register。比如，如果你喜欢使用 tt 作为 Textile 模版的扩展名，你可以这样做：

Tilt.register :tt, Tilt[:textile]

添加你自己的模版引擎

首先，通过 Tilt 注册你自己的引擎，然后创建一个渲染方法：

Tilt.register :myat, MyAwesomeTemplateEngine

helpers do
  def myat(*args) render(:myat, *args) end
end

get '/' do
  myat :index
end

这里调用的是 ./views/index.myat。察看 https://github.com/rtomayko/tilt 来更多了解 Tilt.

过滤器

前置过滤器 (before) 在每个请求前，在请求的上下文环境中被执行，而且可以修改请求和响应。在过滤器中设定的实例变量可以被路由和模板访问：

before do
  @note = 'Hi!'
  request.path_info = '/foo/bar/baz'
end

get '/foo/*' do
  @note #=> 'Hi!'
  params[:splat] #=> 'bar/baz'
end

后置过滤器 (after) 在每个请求之后，在请求的上下文环境中执行，而且可以修改请求和响应。在前置过滤器和路由中设定的实例变量可以被后置过滤器访问：

after do
  puts response.status
end

请注意：除非你显式使用 body 方法，而不是在路由中直接返回字符串，消息体在后置过滤器是不可用的，因为它在之后才会生成。

过滤器可以可选地带有范式 (pattern)，只有请求路径满足该范式 (pattern) 时才会执行：

before '/protected/*' do
  authenticate!
end

after '/create/:slug' do |slug|
  session[:last_slug] = slug
end

和路由一样，过滤器也可以带有条件：

before :agent => /Songbird/ do
  # ...
end

after '/blog/*', :host_name => 'example.com' do
  # ...
end

辅助方法

使用顶层的 helpers 方法来定义辅助方法，以便在路由处理器和模板中使用：

helpers do
  def bar(name)
    "#{name}bar"
  end
end

get '/:name' do
  bar(params[:name])
end

疑问：Sinatra 和区分模块和分组的，都写在同一个文件中不会导致单个文件膨胀，而不可组织吗？答：单独是用 sinatra 构建中型应用太痛苦，可以考虑使用padrino-framework

使用 Sessions

Session 被用来在请求之间保持状态。如果被激活，每一个用户会话对应有一个 session 哈希：

enable :sessions

get '/' do
  "value = " << session[:value].inspect
end

get '/:value' do
  session[:value] = params[:value]
end

请注意 enable :sessions 实际上保存所有的数据在一个 cookie 之中。这可能不会总是做你想要的（比如，保存大量的数据会增加你的流量）。你可以使用任何的Rack session中间件，为了这么做，不要调用 enable :sessions，而是按照自己的需要引入你的中间件：

use Rack::Session::Pool, :expire_after => 2592000

get '/' do
  "value = " << session[:value].inspect
end

get '/:value' do
  session[:value] = params[:value]
end

挂起

要想直接地停止请求 (不处理请求)，在过滤器或者路由中使用：

halt

你也可以指定挂起时的状态码：

halt 410

或者消息体：

halt 'this will be the body'

或者两者;

halt 401, 'go away!'

也可以带消息头：

halt 402, {'Content-Type' => 'text/plain'}, 'revenge'

让路

一个路由可以放弃处理，将处理让给下一个匹配的路由，使用 pass：

get '/guess/:who' do
  pass unless params[:who] == 'Frank'
  'You got me!'
end

get '/guess/*' do
  'You missed!'
end

路由代码块被直接退出，控制流继续前进到下一个匹配的路由。如果没有匹配的路由，将返回 404。

触发另一个路由

有些时候，pass 并不是你想要的，你希望得到的是另一个路由的结果。简单的使用 call 可以做到这一点：

get '/foo' do
  status, headers, body = call env.merge("PATH_INFO" => '/bar')
  [status, headers, body.map(&:upcase)]
end

get '/bar' do
  "bar"
end

请注意在以上例子中，你可以更加简化测试并增加性能，只要简单将"bar"移动到 helper 中，然后就可被/foo 和 /bar 同时使用的 helper。

如果你希望请求被发送到同一个应用，而不是副本，使用 call! 而不是 call.

如果想更多了解 call，请察看 Rack specification 中关于 call 的介绍。

设定消息体，状态码和消息头

通过路由代码块的返回值来设定状态码和消息体不仅是可能的，而且是推荐的。但是，在某些场景中你可能想在作业流程中的特定点上设置消息体。你可以通过 body 辅助方法这么做。如果你这样做了，你可以在那以后使用该方法获得消息体：

get '/foo' do
  body "bar"
end

after do
  puts body
end

也可以传一个代码块给 body，它将会被 Rack 处理器执行（这将可以被用来实现 streaming，参见“返回值”）。

和消息体类似，你也可以设定状态码和消息头：

get '/foo' do
  status 418
  headers \
    "Allow"   => "BREW, POST, GET, PROPFIND, WHEN",
    "Refresh" => "Refresh: 20; http://www.ietf.org/rfc/rfc2324.txt"
  body "I'm a tea pot!"
end

如同 body, 不带参数的 headers 和 status 可以用来访问他们你的当前值。

Streaming Responses

有时候，想要在开始发送数据时依然生成一些响应体。考虑一个极端的例子，在客户端关闭连接之前，一直发送数据。可以使用流辅助方法来避免自己创建包装方法。

get '/' do
  stream do |out|
    out << "It's gonna be legen -\n"
    sleep 0.5
    out << " (wait for it) \n"
    sleep 1
    out << "- dary!\n"
  end
end

可以使用 stream 方法实现流式 API，服务器发送事件以及用作 WebSocket 的基础。该方法同样也可用来提高速度，如果只有部分内容依赖缓慢的资源。

注意:流式行为，特别是并发请求的数据，高度依赖用来提供应用的 web 服务器。有些服务器，比如 WEBRick，根本不支持流。如果服务器不支持流，当传递给流的块结束执行时，响应体将会被立即返回。流并不是包治百病的万金油。

如果可选的参数设置为keep_open, 不会自动对流对象调用 close 方法，而是允许在随后的执行流中手动关闭。这近对那些时间驱动的服务器 (Thin，Rainbows) 起作用，其他服务器依然会关闭流。

# long polling

set :server, :thin
connections = []

get '/subscribe' do
  # register a client's interest in server events
  stream(:keep_open) { |out| connections << out }

  # purge dead connections
  connections.reject!(&:closed?)

  # acknowledge
  "subscribed"
end

post '/message' do
  connections.each do |out|
    # notify client that a new message has arrived
    out << params[:message] << "\n"

    # indicate client to connect again
    out.close
  end

  # acknowledge
  "message received"
end

Logging

在请求范围域中，logger 辅助方法揭示了 Logger 实例：

get '/' do
  logger.info "loading data"
  # ...
end

logger 将自动的考虑 Rack 处理器的设置。如果日志被关闭，该方法将返回一个虚拟的对象，所以，不需要在路由和过滤器中担心它。

注意，日志仅在Sinatra::Application中是默认启动的，如果，从Sinatra::Base中继承，则需要手动的启动日志：

class MyApp < Sinatra::Base
  configure :production, :development do
    enable :logging
  end
end

想要避免启动日志中间件，可以将 logging 设置为 nil。记住，此时 logger 换回为 nil。通用的使用情况是，如果，想要设置自己的 logger，Sinatra 将会使用 env['rack.logger'] 中指定的日志对象。

媒体 (MIME) 类型

使用 send_file 或者静态文件的时候，Sinatra 可能不能识别你的媒体类型。使用 mime_type 通过文件扩展名来注册它们：

mime_type :foo, 'text/foo'

你也可以使用 content_type 辅助方法：

get '/' do
  content_type :foo
  "foo foo foo"
end

生成 URL

为了生成 URL，你需要使用 url 辅助方法，例如，在 Haml 中：

%a{:href => url('/foo')} foo

如果使用反向代理和 Rack 路由，生成 URL 的时候会考虑这些因素。

这个方法还有一个别名 to (见下面的例子).

浏览器重定向

你可以通过 redirect 辅助方法触发浏览器重定向：

get '/foo' do
  redirect to('/bar')
end

其他参数的用法，与 halt 相同：

redirect to('/bar'), 303
redirect 'http://google.com', 'wrong place, buddy'

用 redirect back 可以把用户重定向到原始页面：

get '/foo' do
  "<a href='/bar'>do something</a>"
end

get '/bar' do
  do_something
  redirect back
end

如果想传递参数给 redirect，可以用 query string:

redirect to('/bar?sum=42')

或者用 session:

enable :sessions

get '/foo' do
  session[:secret] = 'foo'
  redirect to('/bar')
end

get '/bar' do
  session[:secret]
end

缓存控制

要使用 HTTP 缓存，必须正确地设定消息头，幂等的 HTTP 动作可缓存。

你可以这样设定 Cache-Control 消息头：

get '/' do
  cache_control :public
  "cache it!"
end

核心提示: 在前置过滤器中设定缓存。

before do
  cache_control :public, :must_revalidate, :max_age => 60
end

如果你正在用 expires 辅助方法设定对应的消息头 Cache-Control 会自动设定：

before do
  expires 500, :public, :must_revalidate
end

为了合适地使用缓存，你应该考虑使用 etag 和 last_modified 方法。推荐在执行繁重任务之前使用这些 helpers，这样一来，如果客户端在缓存中已经有相关内容，就会立即得到显示。

get '/article/:id' do
  @article = Article.find params[:id]
  last_modified @article.updated_at
  etag @article.sha1
  erb :article
end

使用 weak ETag 也是有可能的：

etag @article.sha1, :weak

这些辅助方法并不会为你做任何缓存，而是将必要的信息传送给你的缓存如果你在寻找缓存的快速解决方案，试试 rack-cache:

require "rack/cache"
require "sinatra"

use Rack::Cache

get '/' do
  cache_control :public, :max_age => 36000
  sleep 5
  "hello"
end

发送文件

为了发送文件，你可以使用 send_file 辅助方法：

get '/' do
  send_file 'foo.png'
end

也可以带一些选项：

send_file 'foo.png', :type => :jpg

可用的选项有：

filename：响应中的文件名，默认是真实文件的名字
last_modified：Last-Modified 消息头的值，默认是文件的 mtime（修改时间）。
type：使用的内容类型，如果没有会从文件扩展名猜测。
disposition：用于 Content-Disposition，可能的包括：nil (默认), :attachment 和 :inline
length：Content-Length 的值，默认是文件的大小。

如果 Rack 处理器支持的话，Ruby 进程也能使用除 streaming 以外的方法。如果你使用这个辅助方法，Sinatra 会自动处理 range 请求。

访问请求对象

传入的请求对象可以在请求层（过滤器，路由，错误处理）通过 request 方法被访问：

# 在 http://example.com/example 上运行的应用
get '/foo' do
  request.body              # 被客户端设定的请求体（见下）
  request.scheme            # "http"
  request.script_name       # "/example"
  request.path_info         # "/foo"
  request.port              # 80
  request.request_method    # "GET"
  request.query_string      # ""
  request.content_length    # request.body的长度
  request.media_type        # request.body的媒体类型
  request.host              # "example.com"
  request.get?              # true (其他动词也具有类似方法)
  request.form_data?        # false
  request["SOME_HEADER"]    # SOME_HEADER header的值
  request.referrer          # 客户端的referrer 或者 '/'
  request.user_agent        # user agent (被 :agent 条件使用)
  request.cookies           # 浏览器 cookies 哈希
  request.xhr?              # 这是否是ajax请求？ajax请求不需要返回
  request.url               # "http://example.com/example/foo"
  request.path              # "/example/foo"
  request.ip                # 客户端IP地址
  request.secure?           # false（如果是ssl则为true）
  request.forwarded?        # true （如果是运行在反向代理之后）
  request.env               # Rack中使用的未处理的env哈希
end

一些选项，例如 script_name 或者 path_info 也是可写的：

before { request.path_info = "/" }

get "/" do
  "all requests end up here"
end

request.body 是一个IO或者StringIO对象：

post "/api" do
  request.body.rewind  # 如果已经有人读了它
  data = JSON.parse request.body.read
  "Hello #{data['name']}!"
end

附件

你可以使用 attachment 辅助方法来告诉浏览器响应应当被写入磁盘而不是在浏览器中显示。

get '/' do
  attachment
  "store it!"
end

你也可以传递一个文件名：

get '/' do
  attachment "info.txt"
  "store it!"
end

处理时间和日期

sinatra 提供一个 time_for 的辅助方法，用从给定的值中来生成 Time 对象。其也可用来转换 DateTime，Date 以及相似的类：

get '/' do
  pass if Time.now > time_for('Dec 23, 2012')
  "still time"
end

该方法在expires ，last_modified 和 akin 内部使用。通过覆盖 time_for 方法，可在应用成很容易的扩展这些方法的行为：

helpers do
  def time_for(value)
    case value
    when :yesterday then Time.now - 24*60*60
    when :tomorrow  then Time.now + 24*60*60
    else super
    end
  end
end

get '/' do
  last_modified :yesterday
  expires :tomorrow
  "hello"
end

查找模板文件

find_template 辅助方法被用于在渲染时查找模板文件：

find_template settings.views, 'foo', Tilt[:haml] do |file|
  puts "could be #{file}"
end

这并不是很有用。但是在你需要重载这个方法来实现你自己的查找机制的时候有用。比如，如果你想支持多于一个视图目录：

set :views, ['views', 'templates']

helpers do
  def find_template(views, name, engine, &block)
    Array(views).each { |v| super(v, name, engine, &block) }
  end
end

另一个例子是为不同的引擎使用不同的目录：

set :views, :sass => 'views/sass', :haml => 'templates', :default => 'views'

helpers do
  def find_template(views, name, engine, &block)
    _, folder = views.detect { |k,v| engine == Tilt[k] }
    folder ||= views[:default]
    super(folder, name, engine, &block)
  end
end

你可以很容易地包装成一个扩展然后与他人分享！

请注意 find_template 并不会检查文件真的存在，而是对任何可能的路径调用给入的代码块。这并不会带来性能问题，因为 render 会在找到文件的时候马上使用 break。同样的，模板的路径（和内容）会在除 development mode 以外的场合被缓存。你应该时刻提醒自己这一点，如果你真的想写一个非常疯狂的方法。

配置

运行一次，在启动的时候，在任何环境下：

configure do
  # setting one option
  set :option, 'value'

  # setting multiple options
  set :a => 1, :b => 2

  # same as `set :option, true`
  enable :option

  # same as `set :option, false`
  disable :option

  # you can also have dynamic settings with blocks
  set(:css_dir) { File.join(views, 'css') }
end

只当环境 (RACK_ENV environment 变量) 被设定为 :production 的时候运行：

configure :production do
  ...
end

当环境被设定为 :production 或者 :test 的时候运行：

configure :production, :test do
  ...
end

你可以使用 settings 获得这些配置：

configure do
  set :foo, 'bar'
end

get '/' do
  settings.foo? # => true
  settings.foo  # => 'bar'
  ...
end

可选的设置

absolute_redirects：如果被禁用，Sinatra 会允许使用相对路径重定向，但是，Sinatra 就不再遵守 RFC 2616 标准 (HTTP 1.1), 该标准只允许绝对路径重定向。如果你的应用运行在一个未恰当设置的反向代理之后，你需要启用这个选项。注意 url 辅助方法仍然会生成绝对 URL，除非你传入 false 作为第二参数。默认禁用。
add_charsets：设定 content_type 辅助方法会自动加上字符集信息的多媒体类型。应该添加而不是覆盖这个选项：settings.add_charsets << "application/foobar"
app_file：主应用文件，用来检测项目的根路径，views 和 public 文件夹和内联模板。
bind：绑定的 IP 地址 (默认：0.0.0.0)。仅对于内置的服务器有用。
default_encoding：默认编码 (默认为 "utf-8")。
dump_errors：在 log 中显示错误。
environment：当前环境，默认是 ENV['RACK_ENV']，或者 "development" 如果不可用。
logging：使用 logger
lock：对每一个请求放置一个锁，只使用进程并发处理请求。如果你的应用不是线程安全则需启动。默认禁用。
method_override：使用 _method 魔法以允许在旧的浏览器中在表单中使用 put/delete 方法
port：监听的端口号。只对内置服务器有用。
prefixed_redirects：是否添加 request.script_name 到重定向请求，如果没有设定绝对路径。那样的话 redirect '/foo' 会和 redirect to('/foo') 起相同作用。默认禁用。
public_folder：public 文件夹的位置。
reload_templates：是否每个请求都重新载入模板。在 development mode 和 Ruby 1.8.6 中被企业（用来消除一个 Ruby 内存泄漏的 bug）。
root：项目的根目录。
raise_errors：抛出异常（应用会停下）。
run：如果启用，Sinatra 会开启 web 服务器。如果使用 rackup 或其他方式则不要启用。
running：内置的服务器在运行吗？不要修改这个设置！
server：服务器，或用于内置服务器的列表。默认是 [‘thin’, ‘mongrel’, ‘webrick’], 顺序表明了优先级。
sessions：开启基于 cookie 的 sesson。
show_exceptions：在浏览器中显示一个 stack trace。
static: Sinatra 是否处理静态文件。当服务器能够处理则禁用。禁用会增强性能。默认开启。
static_cache_control：但 Sinatra 处理静态文件时，设置该选项会在响应头信心中添加 Cache-Control 头信息，并且可以使用 cache_control 辅助方法 (默认禁用)。设置多个值时，使用显式数组：set :static_cache_control, [:public, :max_age => 300]
threaded: 设置为 true ，则通知 EventMachine.defer 处理请求
traps：是否处理系统信号
views: views 文件夹。如果没有设置，则根据app_file中的设置。
x_cascade：如果没有匹配路由，是否设置X-Cascade。

环境

有三个预定义的环境："development", "production" 和 "test"。环境可通过 RACK_ENV 变量设置。默认为开发环境。在开发环境中，所有的模板在请求之前，都会重新加载，特殊的not_found和错误处理器将在浏览器中显示堆栈跟踪。在"production" 和 "test"环境中，模板被预先缓存。

为了运行不同的环境，需要设置RACK_ENV变量：

RACK_ENV=production ruby my_app.rb

可通过 development?, test? 和 production? 这些预定义方法检查当前的环境设置：

get '/' do
  if settings.development?
    "development!"
  else
    "not development!"
  end
end

错误处理

错误处理在与路由和前置过滤器相同的上下文中运行，这意味着你可以使用许多好东西，比如 haml, erb, halt，等等。

未找到

当一个 Sinatra::NotFound 错误被抛出的时候，或者响应状态码是 404，not_found 处理器会被调用：

not_found do
  'This is nowhere to be found'
end

错误

error 处理器，在任何路由代码块或者过滤器抛出异常的时候会被调用。异常对象可以通过 sinatra.error Rack 变量获得：

error do
  'Sorry there was a nasty error - ' + env['sinatra.error'].name
end

自定义错误：

error MyCustomError do
  'So what happened was...' + env['sinatra.error'].message
end

那么，当这个发生的时候：

get '/' do
  raise MyCustomError, 'something bad'
end

你会得到：

So what happened was... something bad

另一种替代方法是，为一个状态码安装错误处理器：

error 403 do
  'Access forbidden'
end

get '/secret' do
  403
end

或者一个范围：

error 400..510 do
  'Boom'
end

在运行在 development 环境下时，Sinatra 会安装特殊的 not_found 和 error 处理器。

Rack 中间件

Sinatra 依靠 Rack, 一个面向 Ruby web 框架的最小标准接口。Rack 的一个最有趣的面向应用开发者的能力是支持“中间件”——坐落在服务器和你的应用之间，监视并/或操作 HTTP 请求/响应以提供多样类型的常用功能。

Sinatra 让建立 Rack 中间件管道异常简单，通过顶层的 use 方法：

require 'sinatra'
require 'my_custom_middleware'

use Rack::Lint
use MyCustomMiddleware

get '/hello' do
  'Hello World'
end

use 的语义和在 Rack::Builder DSL(在 rack 文件中最频繁使用) 中定义的完全一样。例如，use 方法接受多个/可变参数，包括代码块：

use Rack::Auth::Basic do |username, password|
  username == 'admin' && password == 'secret'
end

Rack 中分布有多样的标准中间件，针对日志，调试，URL 路由，认证和 session 处理。Sinatra 会自动使用这里面的大部分组件，所以你一般不需要显示地 use 他们。

测试

Sinatra 的测试可以使用任何基于 Rack 的测试程序库或者框架来编写。Rack::Test 是推荐候选：

require 'my_sinatra_app'
require 'test/unit'
require 'rack/test'

class MyAppTest < Test::Unit::TestCase
  include Rack::Test::Methods

  def app
    Sinatra::Application
  end

  def test_my_default
    get '/'
    assert_equal 'Hello World!', last_response.body
  end

  def test_with_params
    get '/meet', :name => 'Frank'
    assert_equal 'Hello Frank!', last_response.body
  end

  def test_with_rack_env
    get '/', {}, 'HTTP_USER_AGENT' => 'Songbird'
    assert_equal "You're using Songbird!", last_response.body
  end
end

请注意：内置的 Sinatra::Test 模块和 Sinatra::TestHarness 类在 0.9.2 版本已废弃。

Sinatra::Base - 中间件，程序库和模块化应用

把你的应用定义在顶层，对于微型应用这会工作得很好，但是在构建可复用的组件时候会带来客观的不利，比如构建 Rack 中间件，Rails metal，带有服务器组件的简单程序库，或者甚至是 Sinatra 扩展。顶层的 DSL 污染了 Object 命名空间，并假定了一个微型应用风格的配置 (例如，单一的应用文件， ./public 和 ./views 目录，日志，异常细节页面，等等）。这时应该让 Sinatra::Base 走到台前了：

require 'sinatra/base'

class MyApp < Sinatra::Base
  set :sessions, true
  set :foo, 'bar'

  get '/' do
    'Hello world!'
  end
end

Sinatra::Base 子类可用的方法实际上就是通过顶层 DSL 可用的方法。大部分顶层应用可以通过两个改变转换成 Sinatra::Base 组件：

你的文件应当引入 sinatra/base 而不是 sinatra; 否则，所有的 Sinatra 的 DSL 方法将会被引进到主命名空间。

把你的应用的路由，错误处理，过滤器和选项放在一个 Sinatra::Base 的子类中。

+Sinatra::Base+ 是一张白纸。大部分的选项默认是禁用的，包含内置的服务器。参见选项和配置查看可用选项的具体细节和他们的行为。

模块化 vs. 传统的方式

与通常的认识相反，传统的方式没有任何错误。如果它适合你的应用，你不需要转换到模块化的应用。

和模块化方式相比，传统的方法只有两个缺点：

你对每个 Ruby 进程只能定义一个 Sinatra 应用，如果你需要更多，切换到模块化方式。
传统方式使用代理方法污染了 Object。如果你打算把你的应用封装进一个 library/gem，转换到模块化方式。

没有任何原因阻止你混合模块化和传统方式。

如果从一种转换到另一种，你需要注意 settings 中的一些微小的不同：

Setting	Classic	Modular
app_file	file loading sinatra	nil
run	$0 == app_file	false
logging	true	false
method_override	true	false
inline_templates	true	false

运行一个模块化应用

有两种方式运行一个模块化应用，使用 run! 来运行：

# my_app.rb
require 'sinatra/base'

class MyApp < Sinatra::Base
  # ... app code here ...

  # start the server if ruby file executed directly
  run! if app_file == $0
end

运行：

ruby my_app.rb

或者使用一个 config.ru，允许你使用任何 Rack 处理器：

# config.ru
require './my_app'
run MyApp

运行：

rackup -p 4567

使用 config.ru 运行传统方式的应用

编写你的应用：

# app.rb
require 'sinatra'

get '/' do
  'Hello world!'
end

加入相应的 config.ru:

require './app'
run Sinatra::Application

什么时候用 config.ru?

以下情况你可能需要使用 config.ru:

你要使用不同的 Rack 处理器部署 (Passenger, Unicorn, Heroku, …).
你想使用一个或者多个 Sinatra::Base 的子类。
你只想把 Sinatra 当作中间件使用，而不是端点。

你并不需要切换到 config.ru 仅仅因为你切换到模块化方式，你同样不需要切换到模块化方式，仅仅因为要运行 config.ru. 把 Sinatra 当成中间件来使用

不仅 Sinatra 有能力使用其他的 Rack 中间件，任何 Sinatra 应用程序都可以反过来自身被当作中间件，被加在任何 Rack 端点前面。这个端点可以是任何 Sinatra 应用，或者任何基于 Rack 的应用程序 (Rails/Ramaze/Camping/…)。

require 'sinatra/base'

class LoginScreen < Sinatra::Base
  enable :sessions

  get('/login') { haml :login }

  post('/login') do
    if params[:name] = 'admin' and params[:password] = 'admin'
      session['user_name'] = params[:name]
    else
      redirect '/login'
    end
  end
end

class MyApp < Sinatra::Base
  # 在前置过滤器前运行中间件
  use LoginScreen

  before do
    unless session['user_name']
      halt "Access denied, please <a href='/login'>login</a>."
    end
  end

  get('/') { "Hello #{session['user_name']}." }
end

变量域和绑定

当前所在的变量域决定了哪些方法和变量是可用的。

应用/类变量域

每个 Sinatra 应用相当与 Sinatra::Base 的一个子类。如果你在使用顶层 DSL(require 'sinatra')，那么这个类就是 Sinatra::Application，或者这个类就是你显式创建的子类。在类层面，你具有的方法类似于 get 或者 before，但是你不能访问 request 对象或者 session, 因为对于所有的请求，只有单一的应用类。

通过 set 创建的选项是类层面的方法：

class MyApp < Sinatra::Base
  # 嘿，我在应用变量域！
  set :foo, 42
  foo # => 42

  get '/foo' do
    # 嘿，我不再处于应用变量域了！
  end
end

在下列情况下你将拥有应用变量域的绑定：

在应用类中
在扩展中定义的方法
传递给 helpers 的代码块
用作set值的过程/代码块

你可以访问变量域对象（就是应用类）就像这样：

通过传递给代码块的对象 (configure { |c| ... })
在请求变量域中使用settings

请求/实例变量域

对于每个进入的请求，一个新的应用类的实例会被创建所有的处理器代码块在该变量域被运行。在这个变量域中，你可以访问 request 和 session 对象，或者调用渲染方法比如 erb 或者 haml。你可以在请求变量域当中通过settings辅助方法访问应用变量域：

class MyApp < Sinatra::Base
  # 嘿，我在应用变量域!
  get '/define_route/:name' do
    # 针对 '/define_route/:name' 的请求变量域
    @value = 42

    settings.get("/#{params[:name]}") do
      # 针对 "/#{params[:name]}" 的请求变量域
      @value # => nil (并不是相同的请求)
    end

    "Route defined!"
  end
end

在以下情况将获得请求变量域：

get/head/post/put/delete 代码块
前置/后置过滤器
辅助方法
模板/视图

代理变量域

代理变量域只是把方法转送到类变量域。可是，他并非表现得 100% 类似于类变量域，因为你并不能获得类的绑定：只有显式地标记为供代理使用的方法才是可用的，而且你不能和类变量域共享变量/状态。(解释：你有了一个不同的 self)。你可以显式地增加方法代理，通过调用 Sinatra::Delegator.delegate :method_name。

在以下情况将获得代理变量域：

顶层的绑定，如果你做过 require "sinatra"
在扩展了 Sinatra::Delegator mixin 的对象

自己在这里看一下代码：Sinatra::Delegator mixin 已经被包含进了主命名空间。

命令行

Sinatra 应用可以被直接运行：

ruby myapp.rb [-h] [-x] [-e ENVIRONMENT] [-p PORT] [-o HOST] [-s HANDLER]

选项是：

-h # help
-p # 设定端口 (默认是 4567)
-o # 设定主机名 (默认是 0.0.0.0)
-e # 设定环境 (默认是 development)
-s # 限定 rack 服务器/处理器 (默认是 thin)
-x # 打开互斥锁 (默认是 off)

必要条件

推荐在 Ruby 1.8.7, 1.9.2, JRuby 或者 Rubinius 上安装 Sinatra。

下面的 Ruby 版本是官方支持的：

Ruby 1.8.6: 不推荐在 1.8.6 上安装 Sinatra，但是直到 Sinatra 1.3.0 发布才会放弃对它的支持。RDoc 和 CoffeScript 模板不被这个 Ruby 版本支持。1.8.6 在它的 Hash 实现中包含一个内存泄漏问题，该问题会被 1.1.1 版本之前的 Sinatra 引发。当前版本使用性能下降的代价排除了这个问题。你需要把 Rack 降级到 1.1.x，因为 Rack >= 1.2 不再支持 1.8.6。
Ruby 1.8.7: 1.8.7 被完全支持，但是，如果没有特别原因，我们推荐你升级到 1.9.2 或者切换到 JRuby 或者 Rubinius.
Ruby 1.9.2: 1.9.2 被支持而且推荐。注意 Radius 和 Markaby 模板并不和 1.9 兼容。不要使用 1.9.2p0, 它被已知会产生 segmentation faults.
Rubinius: Rubinius 被官方支持 (Rubinius >= 1.2.2)，除了 Textile 模板。
JRuby: JRuby 被官方支持 (JRuby >= 1.5.6)。目前未知和第三方模板库有关的问题，但是，如果你选择了 JRuby，请查看一下 JRuby rack 处理器，因为 Thin web 服务器还没有在 JRuby 上获得支持。

我们也会时刻关注新的 Ruby 版本。

下面的 Ruby 实现没有被官方支持，但是已知可以运行 Sinatra:

JRuby 和 Rubinius 老版本 MacRuby Maglev IronRuby Ruby 1.9.0 and 1.9.1

不被官方支持的意思是，如果在不被支持的平台上有运行错误，我们假定不是我们的问题，而是平台的问题。

Sinatra 应该会运行在任何支持上述 Ruby 实现的操作系统。

紧追前沿

如果你喜欢使用 Sinatra 的最新鲜的代码，请放心的使用 master 分支来运行你的程序，它会非常的稳定。

cd myapp git clone git://github.com/sinatra/sinatra.git ruby -Isinatra/lib myapp.rb

我们也会不定期的发布预发布 gems，所以你也可以运行

gem install sinatra --pre

来获得最新的特性。

通过 Bundler

如果你想使用最新的 Sinatra 运行你的应用，通过 Bundler 是推荐的方式。

首先，安装 bundler，如果你还没有安装：

gem install bundler

然后，在你的项目目录下，创建一个 Gemfile:

source :rubygems
gem 'sinatra', :git => "git://github.com/sinatra/sinatra.git"

# 其他的依赖关系
gem 'haml'                    # 举例，如果你想用haml
gem 'activerecord', '~> 3.0'  # 也许你还需要 ActiveRecord 3.x

请注意在这里你需要列出你的应用的所有依赖关系。Sinatra 的直接依赖关系 (Rack and Tilt) 将会，自动被 Bundler 获取和添加。

现在你可以像这样运行你的应用：

bundle exec ruby myapp.rb

使用自己的

创建一个本地克隆并通过 sinatra/lib 目录运行你的应用，通过 $LOAD_PATH:

cd myapp git clone git://github.com/sinatra/sinatra.git ruby -Isinatra/lib myapp.rb

为了在未来更新 Sinatra 源代码：

cd myapp/sinatra git pull

全局安装

你可以自行编译 gem :

git clone git://github.com/sinatra/sinatra.git cd sinatra rake sinatra.gemspec rake install

如果你以 root 身份安装 gems，最后一步应该是

sudo rake install

项目主页（英文） - 更多的文档，新闻，和其他资源的链接。
贡献 - 找到了一个 bug？需要帮助？有了一个 patch?
问题追踪
Twitter
邮件列表
IRC: #sinatra on freenode.net
Sinatra 宝典 Cookbook 教程
Sinatra 使用技巧网友贡献的实用技巧
最新版本API 文档；http://rubydoc.info的当前 HEAD
CI 服务器

xiajian (夏健)

分享如何创建一个新 Ruby Gem

使用指南：

如何将转换成字符串的对象，重新转换成对象？

Redis-objects 介绍

安装和设置 (Installation and Setup)

场景 1：在 Model 类中包含 Redis::Objects

Option 2: Standalone Usage

Locks

过期 (Expiration)

作者 Author

ubuntu 下 rvm 在 oh-my-zsh 下出现了的问题

学习 Vagrant

前言

vagrant 是什么

安装

使用

命令行接口

vagrant 的相关配置

virtualbox

后记

参考文献

Sinatra 中文文档

简介

路由 (route)

条件

返回值

自定义路由匹配器

静态文件

视图 / 模板

字面值模板

可得到的模板语言

Haml 模板

Erb 模板

Erubis

Builder 模板

Nokogiri 模板

Sass 模板

Scss 模板

Less 模板

Liquid 模板

Markdown 模板

Textile 模板

RDoc 模板

Radius 模板

Markaby 模板

Slim 模板

Creole 模板

CoffeeScript 模板

在模板中访问变量

yield 模板和嵌套布局

内联模板

具名模板

关联文件扩展名

添加你自己的模版引擎

过滤器

辅助方法

使用 Sessions

挂起

让路

触发另一个路由

设定 消息体，状态码和消息头

Streaming Responses

Logging

媒体 (MIME) 类型

生成 URL

浏览器重定向

缓存控制

发送文件

访问请求对象

附件

处理时间和日期

查找模板文件

配置

可选的设置

环境

错误处理

未找到

错误

Rack 中间件

设定消息体，状态码和消息头

应用/类变量域

请求/实例变量域