- (void)viewDidLoad
{
    [super viewDidLoad];

    [self.tableView setBackgroundView:nil];
    self.tableView.backgroundColor = [UIColor colorWithRed:248.0/255.0
                                                     green:244.0/255.0
                                                      blue:239.0/255.0 alpha:1.0];
}

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
{
    // Return the number of sections.
    return 4;
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    // Return the number of rows in the section.
    if (section == 0) {
        return 1;
    }
    if (section == 1) {
        return 2;
    }
    if (section == 2) {
        return 4;
    }

    if (section == 3) {
        return 1;
    }


    return 0;
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *CellIdentifier = @"Cell";

    PrettyTableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    if (cell == nil) {
        cell = [[PrettyTableViewCell alloc] initWithStyle:UITableViewCellStyleDefault
                                          reuseIdentifier:CellIdentifier];

        switch (indexPath.section) {
            case 0:
                switch (indexPath.row) {
                    case 0:
                        [self prepareNameCell:cell];
                        break;
                }
                break;
            default:
                break;
        }

        //设置圆角弧度和阴影
        cell.cornerRadius = 5;
        cell.shadowOpacity = 0.07;
        cell.backgroundColor = [UIColor whiteColor];

        //设置选择时候的颜色
        cell.selectionGradientStartColor = [UIColor colorWithRed:248.0/255.0
                                                           green:244.0/255.0
                                                            blue:239.0/255.0 alpha:1];
        cell.SelectionGradientEndColor = [UIColor colorWithRed:248.0/255.0
                                                         green:244.0/255.0
                                                          blue:239.0/255.0 alpha:1];
        // Configure the cell...
        [cell prepareForTableView:tableView indexPath:indexPath];

    }
    return cell;

}

-(void) prepareNameCell:(PrettyTableViewCell *)cell
{
    cell.accessoryType = UITableViewCellAccessoryDisclosureIndicator;

    UILabel *nameLable = [[UILabel alloc] initWithFrame:CGRectMake(5.0, 5.0, 100.0, 15.0)];
    nameLable.text = @"用户名:";
    nameLable.font = [UIFont fontWithName:@"Helvetica-Bold" size:15.0];
    nameLable.translatesAutoresizingMaskIntoConstraints = NO;
    [cell.contentView addSubview:nameLable];


    UILabel *name = [[UILabel alloc] initWithFrame:CGRectMake(5.0, 0.0, 100.0, 15.0)];
    name.text = @"jonny";
    name.translatesAutoresizingMaskIntoConstraints = NO;
    name.font = [UIFont fontWithName:@"Helvetica" size:15.0];

    [cell.contentView addSubview:name];


    NSLayoutConstraint *constraintXName = [NSLayoutConstraint constraintWithItem:name
                                                                        attribute:NSLayoutAttributeLeading
                                                                        relatedBy:NSLayoutRelationEqual
                                                                           toItem: nameLable
                                                                        attribute:NSLayoutAttributeTrailing
                                                                       multiplier:1.0 constant:5.0];


    NSLayoutConstraint *constraintYName = [NSLayoutConstraint constraintWithItem:name
                                                                        attribute:NSLayoutAttributeCenterY
                                                                        relatedBy:NSLayoutRelationEqual
                                                                           toItem: cell.contentView
                                                                        attribute:NSLayoutAttributeCenterY
                                                                       multiplier:1.0 constant:0];

    NSLayoutConstraint *constraintX = [NSLayoutConstraint constraintWithItem:nameLable
                                                                   attribute:NSLayoutAttributeLeading
                                                                   relatedBy:NSLayoutRelationEqual
                                                                      toItem: cell.contentView
                                                                   attribute:NSLayoutAttributeLeading
                                                                  multiplier:1.0 constant:10.0f];


    NSLayoutConstraint *constraintY = [NSLayoutConstraint constraintWithItem:nameLable
                                                                   attribute:NSLayoutAttributeCenterY
                                                                   relatedBy:NSLayoutRelationEqual
                                                                      toItem: cell.contentView
                                                                   attribute:NSLayoutAttributeCenterY
                                                                  multiplier:1.0 constant:0];



    [cell.contentView addConstraints: [[NSArray alloc] initWithObjects:
                                       constraintXName,constraintYName,constraintX,constraintY,nil]];
}

{a,B,C} =  Person

{:a,b,c} = person

Pi = 3.14159.

odds_and_evens(L) ->
    Odds = [X || X <- L, (X rem 2) =:= 1],
    Evens = [X || X <- L, (X rem 2) =:= 0],
    {Odds, Evens}.

filter(P, [H|T]) ->
	case P(H) of
		true -> [H|filter(P, T)];
		false -> filter(P, T)
	end;
filter(P, []) ->
	[].

def hello
	IO.puts "hello world"
end

X > Y X is greater than Y.
X < Y X is less than Y.
X =< Y X is equal to or less than Y.
X >= Y X is greater than or equal to Y.
X == Y X is equal to Y.
X /= Y X is not equal to Y.
X =:= Y X is identical to Y.
X =/= Y X is not identical to Y

a === b # strict equality (so 1 === 1.0 is false)
a !== b # strict inequality (so 1 !== 1.0 is true)
a == b # value equality (so 1 == 1.0 is true)
a != b # value inequality (so 1 != 1.0 is false)
a > b # normal comparison
a >= b # :
a < b # :
a <= b # :

Pid ! Message

Process <- Message

list_to_atom(binary_to_list(capitalize_binary(list_to_binary(atom_to_list(X))))).

X |> atom_to_list |> list_to_binary |> capitalize_binary |> binary_to_list |> binary_to_atom

Name = "jonny".
Sentence = "This is " ++ Name ++ "speaking".

name = "jonny"
sentence = "This is #{name} speaking"

module ActiveSupport
  @load_hooks = Hash.new { |h,k| h[k] = [] }
  @loaded = Hash.new { |h,k| h[k] = [] }

  def self.on_load(name, options = {}, &block)
    @loaded[name].each do |base|
      execute_hook(base, options, block)
    end
    @load_hooks[name] << [block, options]
  end

  def self.execute_hook(base, options, block)
    if options[:yield]
      block.call(base)
    else
      base.instance_eval(&block)
    end
  end

  def self.run_load_hooks(name, base = Object)
    @loaded[name] << base
    @load_hooks[name].each do |hook, options|
      execute_hook(base, options, hook)
    end
  end
end

initializer "active_record.logger" do
    ActiveSupport.on_load(:active_record) { self.logger ||= ::Rails.logger }
end

@load_hooks[name] << [block, options]

ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)

# 覆盖了rack的middleware 方法，加载了3个middleware app
def middleware
      middlewares = []
      middlewares << [Rails::Rack::LogTailer, log_path] unless options[:daemonize]
      middlewares << [Rails::Rack::Debugger]  if options[:debugger]
      middlewares << [::Rack::ContentLength]
      Hash.new(middlewares)
end




# 默认端口改成3000，定义了rack的启动文件config.ru, 还有一些默认配置
def default_options
      super.merge({
        :Port        => 3000,
        :environment => (ENV['RAILS_ENV'] || "development").dup,
        :daemonize   => false,
        :debugger    => false,
        :pid         => File.expand_path("tmp/pids/server.pid"),
        :config      => File.expand_path("config.ru")
      })
end

#引用了config下面的 enviroment.rb 
require ::File.expand_path('../config/environment',  __FILE__)

# RailsStudy是我的rails的项目名称，这里的工作就是run 这个Application
run RailsStudy::Application

require File.expand_path('../boot', __FILE__)

require 'rails/all'

if defined?(Bundler)
  # If you precompile assets before deploying to production, use this line
  Bundler.require(*Rails.groups(:assets => %w(development test)))
  # If you want your assets lazily compiled in production, use this line
  # Bundler.require(:default, :assets, Rails.env)
end

module RailsStudy
  class Application < Rails::Application
    # Settings in config/environments/* take precedence over those specified here.
    # Application configuration should go into files in config/initializers
    # -- all .rb files in that directory are automatically loaded.

    # Custom directories with classes and modules you want to be autoloadable.
    # config.autoload_paths += %W(#{config.root}/extras)

    # Only load the plugins named here, in the order given (default is alphabetical).
    # :all can be used as a placeholder for all plugins not explicitly named.
    # config.plugins = [ :exception_notification, :ssl_requirement, :all ]

    # Activate observers that should always be running.
    # config.active_record.observers = :cacher, :garbage_collector, :forum_observer

    # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
    # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
    # config.time_zone = 'Central Time (US & Canada)'

    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
    config.i18n.default_locale = "zh-CN"

    # Configure the default encoding used in templates for Ruby 1.9.
    config.encoding = "utf-8"

    # Configure sensitive parameters which will be filtered from the log file.
    config.filter_parameters += [:password]

    # Enable escaping HTML in JSON.
    config.active_support.escape_html_entities_in_json = true

    # Use SQL instead of Active Record's schema dumper when creating the database.
    # This is necessary if your schema can't be completely dumped by the schema dumper,
    # like if you have constraints or database-specific column types
    # config.active_record.schema_format = :sql

    # Enforce whitelist mode for mass assignment.
    # This will create an empty whitelist of attributes available for mass-assignment for all models
    # in your app. As such, your models will need to explicitly whitelist or blacklist accessible
    # parameters by using an attr_accessible or attr_protected declaration.
    config.active_record.whitelist_attributes = true

    # Enable the asset pipeline
    config.assets.enabled = true

    # Version of your assets, change this if you want to expire all your assets
    config.assets.version = '1.0'
  end
end

autoload :Configurable,  "rails/railtie/configurable"
autoload :Configuration, "rails/railtie/configuration"

include Initializable

module Rails
  class Railtie
    module Configurable
      extend ActiveSupport::Concern

      module ClassMethods

        delegate :config, :to => :instance

        def inherited(base)
          raise "You cannot inherit from a #{self.superclass.name} child"
        end

        def instance
          @instance ||= new
        end

        ...
      end
    end
  end
end

initializer :add_locales do
  config.i18n.railties_load_path.concat(paths["config/locales"].existent)
end

def initializer(name, opts = {}, &blk)
        raise ArgumentError, "A block must be passed when defining an initializer" unless blk
        opts[:after] ||= initializers.last.name unless initializers.empty? || initializers.find { |i| i.name == opts[:before] }
        initializers << Initializer.new(name, nil, opts, &blk)
end

  def paths
    @paths ||= begin
      paths = Rails::Paths::Root.new(@root)
      paths.add "app",                 :eager_load => true, :glob => "*"
      paths.add "app/assets",          :glob => "*"
      paths.add "app/controllers",     :eager_load => true
      paths.add "app/helpers",         :eager_load => true
      paths.add "app/models",          :eager_load => true
      paths.add "app/mailers",         :eager_load => true
      paths.add "app/views"
      paths.add "lib",                 :load_path => true
      paths.add "lib/assets",          :glob => "*"
      paths.add "lib/tasks",           :glob => "**/*.rake"
      paths.add "config"
      paths.add "config/environments", :glob => "#{Rails.env}.rb"
      paths.add "config/initializers", :glob => "**/*.rb"
      paths.add "config/locales",      :glob => "*.{rb,yml}"
      paths.add "config/routes",       :with => "config/routes.rb"
      paths.add "db"
      paths.add "db/migrate"
      paths.add "db/seeds",            :with => "db/seeds.rb"
      paths.add "vendor",              :load_path => true
      paths.add "vendor/assets",       :glob => "*"
      paths.add "vendor/plugins"
      paths
    end
  end

set_autoload_paths #设置需要自动load的文件路径
add_routing_paths #如果routes文件存在则load相关文件
add_locales  #如果本地化文件存在则load相关文件
load_config_initializers #如果有initializer文件存在则load相关文件

class Application < Engine
    autoload :Bootstrap,      'rails/application/bootstrap'
    autoload :Configuration,  'rails/application/configuration'
    autoload :Finisher,       'rails/application/finisher'
    autoload :Railties,       'rails/application/railties'
    autoload :RoutesReloader, 'rails/application/routes_reloader'


	...
end

module Rails
  class Application
    class Configuration < ::Rails::Engine::Configuration
      attr_accessor :allow_concurrency, :asset_host, :asset_path, :assets,
                    :cache_classes, :cache_store, :consider_all_requests_local,
                    :dependency_loading, :exceptions_app, :file_watcher, :filter_parameters,
                    :force_ssl, :helpers_paths, :logger, :log_tags, :preload_frameworks,
                    :railties_order, :relative_url_root, :reload_plugins, :secret_token,
                    :serve_static_assets, :ssl_options, :static_cache_control, :session_options,
                    :time_zone, :reload_classes_only_on_change, :whiny_nils


   ...
end

 def paths
        @paths ||= begin
          paths = super
          paths.add "config/database",    :with => "config/database.yml"
          paths.add "config/environment", :with => "config/environment.rb"
          paths.add "lib/templates"
          paths.add "log",                :with => "log/#{Rails.env}.log"
          paths.add "public"
          paths.add "public/javascripts"
          paths.add "public/stylesheets"
          paths.add "tmp"
          paths
        end
      end

def initialize!(group=:default) #:nodoc:
    raise "Application has been already initialized." if @initialized
    run_initializers(group, self)
    @initialized = true
    self
end

def run(*args)
    @context.instance_exec(*args, &block)
end

def default_middleware_stack
      ActionDispatch::MiddlewareStack.new.tap do |middleware|
        if rack_cache = config.action_controller.perform_caching && config.action_dispatch.rack_cache
          require "action_dispatch/http/rack_cache"
          middleware.use ::Rack::Cache, rack_cache
        end

        if config.force_ssl
          require "rack/ssl"
          middleware.use ::Rack::SSL, config.ssl_options
        end

        if config.serve_static_assets
          middleware.use ::ActionDispatch::Static, paths["public"].first, config.static_cache_control
        end

        middleware.use ::Rack::Lock unless config.allow_concurrency
        middleware.use ::Rack::Runtime
        middleware.use ::Rack::MethodOverride
        middleware.use ::ActionDispatch::RequestId
        middleware.use ::Rails::Rack::Logger, config.log_tags # must come after Rack::MethodOverride to properly log overridden methods
        middleware.use ::ActionDispatch::ShowExceptions, config.exceptions_app || ActionDispatch::PublicExceptions.new(Rails.public_path)
        middleware.use ::ActionDispatch::DebugExceptions
        middleware.use ::ActionDispatch::RemoteIp, config.action_dispatch.ip_spoofing_check, config.action_dispatch.trusted_proxies

        if config.action_dispatch.x_sendfile_header.present?
          middleware.use ::Rack::Sendfile, config.action_dispatch.x_sendfile_header
        end

        unless config.cache_classes
          app = self
          middleware.use ::ActionDispatch::Reloader, lambda { app.reload_dependencies? }
        end

        middleware.use ::ActionDispatch::Callbacks
        middleware.use ::ActionDispatch::Cookies

        if config.session_store
          if config.force_ssl && !config.session_options.key?(:secure)
            config.session_options[:secure] = true
          end
          middleware.use config.session_store, config.session_options
          middleware.use ::ActionDispatch::Flash
        end

        middleware.use ::ActionDispatch::ParamsParser
        middleware.use ::ActionDispatch::Head
        middleware.use ::Rack::ConditionalGet
        middleware.use ::Rack::ETag, "no-cache"

        if config.action_dispatch.best_standards_support
          middleware.use ::ActionDispatch::BestStandardsSupport, config.action_dispatch.best_standards_support
        end
      end
    end

require 'rubygems'
require 'rack'


class HelloWorld
  def call(env)
    return [200, {}, ["Hello world!"]]
  end
end

Rack::Handler::WEBrick.run(HelloWorld.new,:Port => 9000)

$ ruby myserver.rb
[2012-08-24 12:24:28] INFO  WEBrick 1.3.1
[2012-08-24 12:24:28] INFO  ruby 1.9.3 (2012-04-20) [x86_64-darwin11.4.0]
[2012-08-24 12:24:28] INFO  WEBrick::HTTPServer#start: pid=17920 port=9000

run Proc.new {|env| [200, {"Content-Type" => "text/html"}, ["Hello Rack!"]]}

$ rackup config.ru
[2012-08-24 14:56:34] INFO  WEBrick 1.3.1
[2012-08-24 14:56:34] INFO  ruby 1.9.3 (2012-04-20) [x86_64-darwin11.4.0]
[2012-08-24 14:56:34] INFO  WEBrick::HTTPServer#start: pid=18286 port=9292

class InsertName
    def initialize(app)
      @app = app
    end

    def call(env)
      status, headers, response = @app.call(env)
      [status,headers, [response[0]+ ' jonny']]
    end
end

use InsertName

run Proc.new {|env| [200, {"Content-Type" => "text/html"}, ["Hello Rack!"]]}

use ActionDispatch::Static
use Rack::Lock
use #<ActiveSupport::Cache::Strategy::LocalCache::Middleware:0x007facbb14adb0>
use Rack::Runtime
use Rack::MethodOverride
use ActionDispatch::RequestId
use Rails::Rack::Logger
use ActionDispatch::ShowExceptions
use ActionDispatch::DebugExceptions
use ActionDispatch::RemoteIp
use ActionDispatch::Reloader
use ActionDispatch::Callbacks
use ActiveRecord::ConnectionAdapters::ConnectionManagement
use ActiveRecord::QueryCache
use ActionDispatch::Cookies
use ActionDispatch::Session::CookieStore
use ActionDispatch::Flash
use ActionDispatch::ParamsParser
use ActionDispatch::Head
use Rack::ConditionalGet
use Rack::ETag
use ActionDispatch::BestStandardsSupport
use Warden::Manager
use OmniAuth::Strategies::Weibo
run Opinion::Application.routes

module Rack
  module Handler
    class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
	  def self.run(app, options={})
        options[:BindAddress] = options.delete(:Host) if options[:Host]
        @server = ::WEBrick::HTTPServer.new(options)
        @server.mount "/", Rack::Handler::WEBrick, app
        yield @server  if block_given?
        @server.start
      end

	  ...

  	end
  end
end

class HTTPServer < ::WEBrick::GenericServer
    def initialize(config={}, default=Config::HTTP)
      super(config, default)
      @http_version = HTTPVersion::convert(@config[:HTTPVersion])

      @mount_tab = MountTable.new
      if @config[:DocumentRoot]
        mount("/", HTTPServlet::FileHandler, @config[:DocumentRoot],
              @config[:DocumentRootOptions])
      end

      unless @config[:AccessLog]
        @config[:AccessLog] = [
          [ $stderr, AccessLog::COMMON_LOG_FORMAT ],
          [ $stderr, AccessLog::REFERER_LOG_FORMAT ]
        ]
      end

      @virtual_hosts = Array.new
    end

    ...
end

def start(&block)
      raise ServerError, "already started." if @status != :Stop
      server_type = @config[:ServerType] || SimpleServer

      server_type.start{
        @logger.info \
          "#{self.class}#start: pid=#{$$} port=#{@config[:Port]}"
        call_callback(:StartCallback)

        thgroup = ThreadGroup.new
        @status = :Running
        while @status == :Running
          begin
            if svrs = IO.select(@listeners, nil, nil, 2.0)
              svrs[0].each{|svr|
                @tokens.pop          # blocks while no token is there.
                if sock = accept_client(svr)
                  sock.do_not_reverse_lookup = config[:DoNotReverseLookup]
                  th = start_thread(sock, &block)
                  th[:WEBrickThread] = true
                  thgroup.add(th)
                else
                  @tokens.push(nil)
                end
              }
            end
          rescue Errno::EBADF, IOError => ex
            # if the listening socket was closed in GenericServer#shutdown,
            # IO::select raise it.
          rescue Exception => ex
            msg = "#{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
            @logger.error msg
          end
        end

        @logger.info "going to shutdown ..."
        thgroup.list.each{|th| th.join if th[:WEBrickThread] }
        call_callback(:StopCallback)
        @logger.info "#{self.class}#start done."
        @status = :Stop
      }
end

def service(req, res)
  if req.unparsed_uri == "*"
    if req.request_method == "OPTIONS"
      do_OPTIONS(req, res)
      raise HTTPStatus::OK
    end
    raise HTTPStatus::NotFound, "`#{req.unparsed_uri}' not found."
  end

  servlet, options, script_name, path_info = search_servlet(req.path)
  raise HTTPStatus::NotFound, "`#{req.path}' not found." unless servlet
  req.script_name = script_name
  req.path_info = path_info
  si = servlet.get_instance(self, *options)
  @logger.debug(format("%s is invoked.", si.class.name))
  si.service(req, res)
end

def service(req, res)
  ...
  status, headers, body = @app.call(env)
  ...
end

  version :small do
    process :resize_to_fill => [48,48]
  end

 def crop_area
    manipulate! do |img|
      ...
    end
  end

# model class
# define attr_accessor coords
class User < ActiveRecord::Base
  attr_accessor :coords
  mount_uploader :icon, AvatarUploader
end



# controller
# pass the params to @user.coords
def crop_icon
  @user.coords = params[:coords]
  @user.icon = File.open(path)
  @user.save
  redirect_to :action=> 'basic'
end



# Uploader
# the model in the function is same as @user in controll,
# and can be invoked inside of process method 
 def crop_area
    manipulate! do |img|
      unless model.coords.nil?
        coords = JSON.parse(model.coords)
        img.crop("#{coords['w']}x#{coords['h']}+#{coords['x']}+#{coords['y']}")
      end
      img = yield(img) if block_given?
      img
    end
  end

#!/usr/bin/env ruby
#
# This file was generated by RubyGems.
#
# The application 'railties' is installed as part of a gem, and
# this file is here to facilitate running it.
#

require 'rubygems'

version = ">= 0"

if ARGV.first
  str = ARGV.first
  str = str.dup.force_encoding("BINARY") if str.respond_to? :force_encoding
  p str
  if str =~ /\A_(.*)_\z/
    version = $1
    ARGV.shift
  end
end

gem 'railties', version
load Gem.bin_path('railties', 'rails', version)

p Gem.bin_path('railties', 'rails', version)
# will out put /*/*/ruby-1.9.3-p194/gems/railties-3.2.7/bin/rails

#!/usr/bin/env ruby

if File.exists?(File.join(File.expand_path('../../..', __FILE__), '.git'))
  railties_path = File.expand_path('../../lib', __FILE__)
  $:.unshift(railties_path)
end
require "rails/cli"

require 'rbconfig'
require 'rails/script_rails_loader'

# If we are inside a Rails application this method performs an exec and thus
# the rest of this script is not run.
Rails::ScriptRailsLoader.exec_script_rails!

require 'rails/ruby_version_check'
Signal.trap("INT") { puts; exit(1) }

if ARGV.first == 'plugin'
  ARGV.shift
  require 'rails/commands/plugin_new'
else
  require 'rails/commands/application'
end

module Rails
  module ScriptRailsLoader
    RUBY = File.join(*RbConfig::CONFIG.values_at("bindir", "ruby_install_name")) + RbConfig::CONFIG["EXEEXT"]
    SCRIPT_RAILS = File.join('script', 'rails')

    def self.exec_script_rails!
      cwd = Dir.pwd
      return unless in_rails_application? || in_rails_application_subdirectory?
      exec RUBY, SCRIPT_RAILS, *ARGV if in_rails_application?
	  ...	
    rescue SystemCallError
      # could not chdir, no problem just return
    end

    ...

  end
end

#!/usr/bin/env ruby
# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.

APP_PATH = File.expand_path('../../config/application',  __FILE__)
require File.expand_path('../../config/boot',  __FILE__)
require 'rails/commands'

when 'server'
  # Change to the application's path if there is no config.ru file in current dir.
  # This allows us to run script/rails server from other directories, but still get
  # the main config.ru and properly set the tmp directory.
  Dir.chdir(File.expand_path('../../', APP_PATH)) unless File.exists?(File.expand_path("config.ru"))

  require 'rails/commands/server'
  Rails::Server.new.tap { |server|
    # We need to require application after the server sets environment,
    # otherwise the --environment option given to the server won't propagate.
    require APP_PATH
    Dir.chdir(Rails.application.root)
    server.start
  }

 def start
      url = "#{options[:SSLEnable] ? 'https' : 'http'}://#{options[:Host]}:#{options[:Port]}"
      puts "=> Booting #{ActiveSupport::Inflector.demodulize(server)}"
      puts "=> Rails #{Rails.version} application starting in #{Rails.env} on #{url}"
      puts "=> Call with -d to detach" unless options[:daemonize]
      trap(:INT) { exit }
      puts "=> Ctrl-C to shutdown server" unless options[:daemonize]

      #Create required tmp directories if not found
      %w(cache pids sessions sockets).each do |dir_to_make|
        FileUtils.mkdir_p(Rails.root.join('tmp', dir_to_make))
      end

      super
    ensure
      # The '-h' option calls exit before @options is set.
      # If we call 'options' with it unset, we get double help banners.
      puts 'Exiting' unless @options && options[:daemonize]
  end

require 'active_support'
require 'active_support/dependencies/autoload'

require 'action_pack'
require 'active_model'
require 'rack'

List<Apple> box = ...;
Apple apple = box.get(0);

List box = ...;
Apple apple = (Apple) box.get(0);

public interface List<T> extends Collection<T> {
	...
}

T get(int index);

public static <t> T getFirst(List<T> list)

List<String> str = new ArrayList<String>();
str.add("Hello ");
str.add("World.");

str.add(1); // 不能编译

String myString = str.get(0);

for (Iterator<String> iter = str.iterator(); iter.hasNext();) {
    String s = iter.next();
    System.out.print(s);
}

for (String s: str) {
    System.out.print(s);
}

List<Integer> ints = new ArrayList<Integer>();
ints.add(0);
ints.add(1);
 
int sum = 0;
for (int i : ints) {
    sum += i;
}

Apple a = ...;
Fruit f = a;

List<Apple> apples = ...;
List<Fruit> fruits = apples;

List<Apple> apples;
List<Fruit> fruits = ...;
apples = fruits;

List apples = ...;
List fruits = apples;
fruits.add(new Strawberry());

Apple[] apples = ...;
Fruit[] fruits = apples;

Apple[] apples = new Apple[1];
Fruit[] fruits = apples;
fruits[0] = new Strawberry();

void sort(Object[] o);

List<Apple> apples = new ArrayList<Apple>();
List<? extends Fruit> fruits = apples;

List<Fruit> fruits = new ArrayList<Fruit>();
List<? super Apple> = fruits;

Apple[] apples = new Apple[1];
Fruit[] fruits = apples;
fruits[0] = new Strawberry();

List<Apple> apples = new ArrayList<Apple>();
List<? extends Fruit> fruits = apples;
fruits.add(new Strawberry());

fruits.add(new Fruit());

Fruit get = fruits.get(0);

List<Fruit> fruits = new ArrayList<Fruit>();
List<? super Apple> = fruits;

fruits.add(new Apple());
fruits.add(new GreenApple());

fruits.add(new Fruit());
fruits.add(new Object());