function todoApp(state = initialState, action) {
  switch (action.type) {
    case SET_VISIBILITY_FILTER:
      return Object.assign({}, state, {
        visibilityFilter: action.filter
      });
    case COMPLETE_TODO:
      return Object.assign({}, state, {
        todos: todos(state.todos, action)
      });
    default:
      return state;
  }
}

# 创建组件
React.createClass()

# 相当于
class ChainSelectBox extends Component {

}

class ApprovalChainManage extends Component {

    render() {
        return <ChildComponent></ChildComponent>
    }
}

# 当 state 有更新的时候，就会被调用
const mapStateToProps = ( state ) => {
  return {
    approvalChainEntities:       state.ApprovalChainEntity
  }
};

# 将 actions 传入 props
const mapDispatchToProps = ( dispatch ) => ( {
  approvalChainActions:       bindActionCreators( approvalChainActions, dispatch )
} );


export default connect( mapStateToProps, mapDispatchToProps )( ApprovalChainManage );

# 子组件
class ChildComponent extends Component {

    render() {
        # JSX 语法
        return (
            <div>
                <span>Yo yo</span>
            </div>
        )
    }
}

const mapStateToProps = ( state ) => {
  return {
    approvalChainEntities:       state.ApprovalChainEntity
  }
};

const mapDispatchToProps = ( dispatch ) => ( {
   studentActions:       bindActionCreators( StudentActions, dispatch )
} );


export default connect( mapStateToProps, mapDispatchToProps )( ApprovalChainManage );


# 父组件
class ApprovalChainManage extends Component {

    render() {
        return <ChildComponent></ChildComponent>
    }
}

# 当 state 有更新的时候，就会被调用
const mapStateToProps = ( state ) => {
  return {
    approvalChainEntities:       state.ApprovalChainEntity
  }
};

# 将 actions 传入 props
const mapDispatchToProps = ( dispatch ) => ( {
  approvalChainActions:       bindActionCreators( approvalChainActions, dispatch )
} );


export default connect( mapStateToProps, mapDispatchToProps )( ApprovalChainManage );

# 第一次是因为初始化，第二次是因为connect
const mapStateToProps = ( state ) => {
  console.log("开始 state cashview")
  return {
    entities: state.cashEntity
  }
};

 <Route path='/' component={Root}>
    <IndexRoute component={LoginView} />
      <Route path='cash' component={CashView}>
        <Route path='product/:id' component={CashProductDetail}></Route>
        <Route path='index' component={CashIndex}></Route>
      </Route>
 </Route>

class CashView extends Component {

  render () {
    const {
      entities, actions, children, publicEntities, publicActions
    } = this.props;

    return (
      <div>
        <div className="er-header">
          <Header navBarIndex={1}></Header>
        </div>
        # 这里来根据路由加载不同的子组件
        # 使用 cloneElement 的原因是为了将数据传入子组件
        # cloneElement 并非是真正的 clone, 只是将我们传入的数据进行合并罢了
        {cloneElement(children, { entities, actions, publicEntities, publicActions })}
        <Footer/>
      </div>
    );
  }
}

class Teacher extends Component {
    construtor() {
        # 由于使用了 ES6 语法，因此不能用 defaultState 属性来进行初始化
        this.state = {
            name: 'fancy'
        }
    }

    componentWillMount(){
        if(this.props.rightLinkTxt){
          # 更改该组件的 state, 此时该组件会重新 render, 父级组件不受影响
          this.setState({
            name: 'nancy'
          });
        }
    }
}

# 以下按顺序发生
1. url
2. url?params=123   => 直接按enter => 刷新动作
3. url?params=12 => 直接按enter => update
4. url?params=112 => 直接按enter => update
5. url?params=122 => 直接按enter => update
6. url?params= => 直接按enter => 刷新动作

export default combineReducers({
  router: routerStateReducer,
  loginEntity,
  homeEntity
})

// 实际上转换的是：

export default {
  router: routerStateReducer(state.router, action),
  // 注意这里的 state.loginEntity，这就是为什么我们在自己的 reducer 只能够拿到自己相关 entites 内容的原因。
  loginStzEntity: loginStzEntity(state.loginStzEntity, action),
  homeEntity: homeEntity(state.homeEntity, action),
}

// 根rootReducer 返回所有 state 的内容

// 这样子以后发的action通通都会被 rootReducer 所接收到
const store = createStoreWithMiddleware( createStore )(
    rootReducer, initialState
);

// 也就是说一个 action 会被里面所有的子 reducer 所接收~

class Father extends Component(){

    render() {
        return ( <Children></Children> )
    }
}

class Children extends Component(){
    
    doSomething() {
        # setState 后, this.state 的值并不会立马更新！
        this.setState({
            name: "fancy"
        })
        # 这里会执行完，才进行重新 render
        console.log("yo");
    }
    
    render() {
        return ( <div> Yo </div> )
    }
}

function shouldComponentUpdate(nextProps, nextState) {
  return shallowCompare(this, nextProps, nextState);
}

function pureRende(component) {
  component.prototype.shouldComponentUpdate = shouldComponentUpdate;
}
module.exports = pureRender;

getAsync("fileA.txt", function(error, result){
    if(error){// 取得失败时的处理
        throw error;
    }
    // 取得成功时的处理
});

var promise = getAsyncPromise("fileA.txt");
promise.then(function(result){
    // 获取文件内容成功时的处理
}).catch(function(error){
    // 获取文件内容失败时的处理
});

function asyncFunction() {
    return new Promise(function (resolve, reject) {
        var num = Math.random() * 100;
        if (num > 50) {
            // 成功事件
            resolve('yo');
        } else {
            // 失败事件
            reject('sad');
        }
    });
}

// 第一种写法
asyncFunction().then(function (value) {
    console.log(value);    // => 'yo'
}).catch(function (error) {
    console.log(error);    // => 'sad'
});

// 第二种写法
asyncFunction().then(function (value) {
    console.log(value);    // => 'yo'
}, function (error) { // 注意这里是个逗号
    console.log(error);    // => 'sad'
});

# then() 方法可以同时处理成功状态以及失败状态
promise.then(function onResolve(){}, function onReject(){})

# 不过最好还是使用下面这种方法
# 因为这样在 then() 中发生的错误也可以在 catch() 内捕捉到
promise.then(
    function onResolve(){}
).catch(
    function onReject(){}
)

# promise.catch() 相当于
promise.then(undefined, onReject(){
    ...
});

Promise.resolve(42)

# 直接将状态变为成功状态
new Promise(function(resolve){
    resolve(42);
})

Promise.resolve(42).then(function (value){
    console.log(value)
})

Promise.reject(42)

new Promise(function(resolve, reject){
    reject(42);
})

Promise.reject(new Error("BOOM!")).catch(function(error){
    console.error(error);
});

var promise = new Promise(function (resolve){
    console.log("inner promise"); // 1
    resolve(42);
});
promise.then(function(value){
    console.log(value); // 3
});
console.log("outer promise"); // 2

inner promise // 1
42            // 2
outer promise // 3

inner promise // 1
outer promise // 2
42            // 3

promise.then(function taskA(value){
    return 'hello'
}).then(function taskB(value){
    console.log(value)   // => 'hello'
}).catch(function onRejected(error){
    console.log(error);
});

var promise = new Promise(function(resolve, reject){
    throw new Error("message");
});
promise.catch(function(error){
    console.error(error);// => "message"
});

var promise = new Promise(function(resolve, reject){
    reject(new Error("message"));
});
promise.catch(function(error){
    console.error(error);// => "message"
})

var onRejected = console.error.bind(console);
var promise = Promise.resolve();
promise.then(function () {
    return Promise.reject(new Error("this promise is rejected"));
}).catch(onRejected);

function throwError(value) {
    // 抛出异常
    throw new Error(value);
}
// <1> onRejected不会被调用
function badMain(onRejected) {
    return Promise.resolve(42).then(throwError, onRejected);
}
// <2> 有异常发生时onRejected会被调用
function goodMain(onRejected) {
    return Promise.resolve(42).then(throwError).catch(onRejected);
}
// 运行示例
badMain(function(){
    console.log("BAD");
});
goodMain(function(){
    console.log("GOOD");
});

first_promise = new Promise(function(resolve, reject){
    ...
})
second_promise = new Promise(function(resolve, reject){
    ...
})
Promise.all([first_promise, second_promise]).then(function(results)){
    console.log(results)  // 按照数组顺序返回的值
}

// `delay`毫秒后执行resolve
function timerPromisefy(delay) {
    return new Promise(function (resolve) {
        setTimeout(function () {
            resolve(delay);
        }, delay);
    });
}
// 任何一个promise变为resolve或reject 的话就执行then()方法
Promise.race([
    timerPromisefy(1),
    timerPromisefy(32),
    timerPromisefy(64),
    timerPromisefy(128)
]).then(function (value) {
    console.log(value);    // => 1
});

var promise = Promise.reject(new Error("message"));
promise["catch"](function (error) {
    console.error(error);
});

小时候，自由是一张破旧的五角钱，我在这头，美食在外头。

长大了，自由是一纸灼人的高考卷，我在这头，大学在外头。

后来啊，自由是一道宏伟的柏林墙，我在这头，世界在外头。

Chrome : 点开设置你会发现它是默认是用系统代理设置的
QQ : 不使用系统代理设置，可以自定义代理设置
邮件: 默认系统代理设置

# .zshrc / .bashrc 等配置文件之一
export http_proxy=proxy_addr:port

brew install proxychains-ng

$ vim /usr/local/etc/proxychains.conf

# edit
strict_chain
proxy_dns
remote_dns_subnet 224
tcp_read_time_out 15000
tcp_connect_time_out 8000
localnet 127.0.0.0/255.0.0.0
quiet_mode

[ProxyList]
socks5  127.0.0.1 1080

# 本地开启的服务正是 1080 端口

proxychains4 -q curl 'google.com'

## 添加 alias(在 .zshrc / .bashrc ....)
alias ss="proxychains4 -q"

## 简化
ss curl 'google.com'

SHELL 发出 request => ProxyChains-NG 将 HTTP 流量转换成 SOCKS5 流量 =>

本地 SS 服务 转发请求到 远程 SS 服务器 => SS 服务器请求实际 request, 将 response 返回

brew install polipo

vim /usr/local/opt/polipo/homebrew.mxcl.polipo.plist

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
   <dict>
     <key>Label</key>
     <string>homebrew.mxcl.polipo</string>
     <key>RunAtLoad</key>
     <true/>
     <key>KeepAlive</key>
     <true/>
     <key>ProgramArguments</key>
     <array>
       <string>/usr/local/opt/polipo/bin/polipo</string>
       <string>socksParentProxy=localhost:1080</string>
     </array>
     <!-- Set `ulimit -n 65536`. The default macOS limit is 256, that's
          not enough for Polipo (displays 'too many files open' errors).
          It seems like you have no reason to lower this limit
          (and unlikely will want to raise it). -->
     <key>SoftResourceLimits</key>
     <dict>
       <key>NumberOfFiles</key>
       <integer>65536</integer>
     </dict>
   </dict>
 </plist>

ln -sfv /usr/local/opt/polipo/*.plist ~/Library/LaunchAgents
launchctl load ~/Library/LaunchAgents/homebrew.mxcl.polipo.plist

vim ~/.zshrc

alias proxy="export http_proxy=http://localhost:8123;export https_proxy=http://localhost:8123"  # 开启
alias unproxy="unset http_proxy"  # 关闭

# 开始使用代理
$ proxy
$ todo ...


# 取消使用代理
$ unproxy
$ todo ...

# 有人会发现 ping 无法翻墙
ss ping google.com

class Teacher < ActiveRecord::Base
    has_and_belongs_to_many :students
end

class Student < ActiveRecord::Base
    has_and_belongs_to_many :Teacher
end

# 手动创中间表(migration，注意该表没有主键)
create table :teachers_students, id: false do |t|
    t.integer :teacher_id
    t.integer :student_id
end

# 用户
class User < ActiveRecord::Base
  has_many :comments
  # 如果用户不需要找到帖子, 那么可以不用写关联
  has_many :posts, through: :comments
end

# 帖子
class Post < ActiveRecord::Base
  has_many :comments
  has_many :users, through: :comments
end

# 评论
class Comment < ActiveRecord::Base
  belongs_to :posts
  belongs_to :users
end

# 供应商
class Supplier < ActiveRecord::Base
  has_one :account
end

# 账号
class Account < ActiveRecord::Base
  belongs_to :supplier
  has_one :account_history
end

# 历史账号
class AccountHistory < ActiveRecord::Base
  belongs_to :account
end

# 供应商通过账号来查找历史账号
supplier.account.account_history

# 供应商
class Supplier < ActiveRecord::Base
  has_one :account
  has_one :account_history, through: account
end

# 账号
class Account < ActiveRecord::Base
  belongs_to :supplier
  has_one :account_history
end

# 历史账号
class AccountHistory < ActiveRecord::Base
  belongs_to :account
end

supplier.account_history

class Picture < ActiveRecord::Base
  belongs_to :imageable, polymorphic: true
end

class Post < ActiveRecord::Base
  has_many :pictures, as: :imageable
end

class Comment < ActiveRecord::Base
  has_many :pictures, as: :imageable
end

# 获取子对象
post.pictures
comment.pictures

# 获取父对象
picture.post

class CreatePictures < ActiveRecord::Migration
  def change
    create_table :pictures do |t|
      t.string  :name
      # 外键id
      t.integer :imageable_id
      # 具体是属于哪个父对象
      t.string  :imageable_type
      t.timestamps
    end
  end
end

class Genre < ActiveRecord::Base
  has_many :genre_recommends
  # 找到该分类下的推荐 apps
  has_many :apps, through: :genre_recommend
end

class App < ActiveRecord::Base
  has_many :genre_recommends
  # 这里并不需要找到 genre, 因此可以不写
  has_many :genres, through: :genre_recommend
end

class GenreRecommend < ActiveRecord::Base
  belongs_to :genre
  belongs_to :app
end

# 一般使用（但 apps 有可能会跟其他冲突, 比如找出该分类下的所有 apps）
@genre.apps

# 实际上这么使用会更友好
@genre.recommends

class Genre < ActiveRecord::Base
  has_many :genre_recommends
  # 找到该分类下的推荐 apps
  has_many :recommends, source: :app, through: :genre_recommend
end

class App < ActiveRecord::Base
  has_many :genre_recommends
end

class GenreRecommend < ActiveRecord::Base
  belongs_to :genres
  belongs_to :app
end

class Customer < ActiveRecord::Base
  has_many :orders, class_name: "Transaction"
end

class Person < ActiveRecord::Base
  # 这样删除一个 person 时，还会删除名下的所有 contacts
  has_many :contacts, dependent: :destroy
end

class Contact < ActiveRecord::Base
  belongs_to :person
end

class Person < ActiveRecord::Base
  has_many :contacts, dependent: :destroy
end

class Contact < ActiveRecord::Base
  belongs_to :person
end

@person = Person.first
c1 = Contact.new
c2 = Contact.new

# 此时会自动保存 c1 c2，官方说因为 c1 c2 要更新外键 ( 这点不太明 )
@person.contacts << c1
@person.contacts << c2

class Post < ActiveRecord::Base
  has_many :comments
  # 只读，否则被串改就不好了。
  attr_readonly :comments_count
end

class Comment < ActiveRecord::Base
  belongs_to :post, counter_cache: true
end

def change
  add_column :posts, :comments_count, :integer
end

@post.comments.size

aptitude install monit

 set httpd port 2812 and
    use address 172.16.10.6
    allow localhost   # 允许本地访问
    allow 172.16.20.0/255.255.255.0 #允许本 IP 段访问
    allow admin:monit      # require user 'admin' with password 'monit'

<!-- 检查周期，单位为秒-->
set daemon 120

<!-- 日志文件位置 -->
set logfile /var/log/monit.log

<!-- 存储 monit 实例的唯一 ID-->
set idfile /var/lib/monit/id

<!-- 存放监控进程的情况 -->
set statefile /var/lib/monit/state

<!-- 设置邮件-->
set mailserver smtp.aa.com port 25 USERNAME "aa@aa.com" PASSWORD "123456"

# 如果没配置 email, 会自动丢弃 alert
# 该设置可以保存 alert
set eventqueue
      basedir /var/lib/monit/events
      slots 100


<!-- Email 格式 -->
set mail-format {
     from: monit@$HOST
  subject: monit alert --  $EVENT $SERVICE
  message: $EVENT Service $SERVICE
                Date:        $DATE
                Action:      $ACTION
                Host:        $HOST
                Description: $DESCRIPTION

           Your faithful employee,
           Monit
}

# 制定报警邮件的格式
set mail-format {
  from: aa@aa.com
  subject: $SERVICE $EVENT at $DATE
  message: Monit $ACTION $SERVICE at $DATE on $HOST: $DESCRIPTION.
}

<!-- Email 接收人-->
 set alert sysadm@foo.bar with reminder on 3 cycles

<!-- 开启 http 服务，查看监控情况-->

set httpd port 2812 and
    use address 172.16.10.6  # only accept connection from localhost
    #allow localhost
    #allow 172.16.20.0/255.255.255.0
    #allow 10.0.0.0        # allow localhost to connect to the server and
    allow admin:monit      # require user 'admin' with password 'monit'
   # allow @monit           # allow users of group 'monit' to connect (rw)
   # allow @users readonly  # allow users of group 'users' to connect readonly

include /etc/monit/conf.d/*

# 包含该文件夹下的配置
include /etc/monit/conf.d/*

# 检查语法
sudo monit -t

# 重载配置
sudo monit reload

check filesystem datafs with path /dev/vdb
  if space usage > 50% then alert
  group server

check process nginx with pidfile /opt/nginx/logs/nginx.pid
  start program = "/etc/init.d/nginx start"
  stop program  = "/etc/init.d/nginx stop"
  group www-data

check process puma_glassx
  with pidfile "/mnt/glassx/shared/tmp/pids/puma.pid"
  start program = "/usr/bin/sudo -u deployer /bin/bash -c 'cd /mnt/glassx/current && ~/.rvm/bin/rvm ruby-2.1.2 do bundle exec puma -C /mnt/glassx/shared/puma.rb --daemon'"
  stop program = "/usr/bin/sudo -u deployer /bin/bash -c 'cd /mnt/glassx/current && ~/.rvm/bin/rvm ruby-2.1.2 do bundle exec pumactl -S /mnt/glassx/shared/tmp/pids/puma.state stop'"

# 这里使用 /bin/su - deploy ，以用户deploy的环境去执行后续命令
check process process_server
  with pidfile "xxxx.pid"
  start program = "/bin/su - deploy  -c 'ruby xxx"
  stop program = "/bin/su - deploy  -c 'ruby xxx'"
 if 5 restarts with in 10 cycles then timeout

# Load DSL and Setup Up Stages
require 'capistrano/setup'

require 'capistrano/deploy'
#
require 'capistrano/rvm'
require 'capistrano/bundler'
require 'capistrano/rails/assets'
require 'capistrano/rails/migrations'
require 'capistrano/sidekiq'
# 打开 monit 的监控 tasks
require 'capistrano/sidekiq/monit'
require 'capistrano/puma'
# 打开 monit 的监控 tasks
require 'capistrano/puma/monit'

# Loads custom tasks from `lib/capistrano/tasks' if you have any defined.
Dir.glob('lib/capistrano/tasks/*.rake').each { |r| import r }

set :sidekiq_default_hooks, false

# 将 monit 的监控配置上传到服务器
cap production puma:monit:config
cap production sidekiq:monit:config

sudo mv /tmp/monit.conf /etc/monit/conf.d/puma_glassx.conf
sudo mv /tmp/monit.conf /etc/monit/conf.d/sidekiq_glassx.conf

 # This is an upstart script to keep monit running.
 # To install disable the old way of doing things:
 #
 #   /etc/init.d/monit stop && update-rc.d -f monit remove
 #
 # then put this script here:
 #
 #   /etc/init/monit.conf
 #
 # and reload upstart configuration:
 #
 #   initctl reload-configuration
 #
 # You can manually start and stop monit like this:
 # 
 # start monit
 # stop monit
 #

 description "Monit service manager"

 limit core unlimited unlimited

 start on runlevel [2345]
 stop on starting rc RUNLEVEL=[016]

 expect daemon
 respawn

 exec /usr/local/bin/monit -c /etc/monit/monitrc

 pre-stop exec /usr/local/bin/monit -c /etc/monit/monitrc quit

# 加载配置文件
initctl reload-configuration
# 启动 monit
start monit

class Account < ActiveRecord::Base
  validates_presence_of :email, :message => "Email 不得为空"
end

account = Account.new

# 此时会调用 account.valid?，该 valid? 会调用所有validate，通过则 true,否则为 false
account.save   => false
account.valid? => false
account.errors.empty?  => false
account.email = 'linjunzhugg@gmail.com'
account.valid? => true
account.save   => true

# File activemodel/lib/active_model/validations.rb, line 331
def valid?(context = nil)
  current_context, self.validation_context = validation_context, context
  errors.clear
  run_validations!
ensure
  self.validation_context = current_context
end

# File activemodel/lib/active_model/validations.rb, line 394
def run_validations!
  _run_validate_callbacks
  errors.empty?
end

# user.rb
class Account < ActiveRecord::Base
  # 不要在这里手动写 message，应该在 locals 中的 yml 文件写
  # validates_presence_of :email, :message => "Email 不得为空"
  validates_presence_of :email
end

# users_controller.rb
def create
  @user = User.new(user_params)
  if @user.save
    render :index
  else
    # save 失败后会将错误信息存入  @user.errors
    # 就不用自己在这里写错误信息了
    render :new
  end
end

activerecord.errors.models.user.attributes.name.blank
activerecord.errors.models.user.blank
activerecord.errors.messages.blank
errors.attributes.name.blank
errors.messages.blank

class Admin < User
  validates :name, presence: true
end

activerecord.errors.models.admin.attributes.name.blank
activerecord.errors.models.admin.blank
activerecord.errors.models.user.attributes.name.blank
activerecord.errors.models.user.blank
activerecord.errors.messages.blank
errors.attributes.name.blank
errors.messages.blank

zh-CN:
  activerecord:
    attributes:
      user:
        email: 'Email'
        password: '密码'
      work_order:
        title: '标题'
        question: '问题'
    errors:
      # 执行 errors.full_message 会按照此格式输出
      format: ! '%{attribute}%{message}'
      # 这里作为通用的错误信息
      messages:
        blank: "%{attribute} 不能为空"
        invalid: "%{attribute} 格式不正确"
        taken: "%{attribute} 已经被使用"
      # 这里作为针对性的 model 错误信息
      models:
        user:
          attributes:
            password:
              too_short: '密码 不得小于6位'

zh-CN:
  activerecord:
    attributes:
      user:
        email: 'Email'

  avtiverecord:
    errors:
      messages:
        blank: "%{attribute} 不能为空"

不要这么写，这样后面的 activerecord 会覆盖掉前面的东西，而不是作为一个 namespace 的存在。

# users_controller.rb
def create
  @user = User.new(user_params)
  if @user.save
    render :index
  else
    # 直接在 view 层去显示错误信息
    render :new
  end
end

# users_helper.rb
def show_error model, column
  if model.send('errors')[column][0]
    sanitize "<div class='error-msg'>* #{model.send('errors')[column][0]}</div>"
  end
end

# users/new.html.erb

<html>
<body>
  oooooooooxxxxxxxxx
  # 此时这里就可以按照需求显示出我们在 yml 中自定义的错误信息了
  show_error(@user, :avatar)
</body>
</html>

# users_controller.rb

def update
  if user_pass?
    # 自己在 yml 中定义错误信息
    flash[:success] =  I18n.t("web.messages.success")
  else
    flash[:error] =  I18n.t("web.messages.failed")
  end

end

class User < ActiveRecord::Base
  validate :file_size

  private

  def file_size
    if avatar.file.size.to_f/(1000) > 500
      errors[:avatar] << I18n.t("activerecord.errors.models.user.attribuets.avatar.too_long")
    end
  end
end

  def file_size
    p self   => 会发现其实是当前实例 @user
  end

 errors[:avatar] << I18n.t("activerecord.errors.models.user.attribuets.avatar.too_long")

def file_size
  if avatar.file.size.to_f/(1000) > 500
    # 这样就会调用到`model`的错误信息 (:column, :event_key)
    # 也不用写那么长了
    errors[:avatar] << errors.generate_message(:avatar, :too_long)
  end
end

<div class="field_with_errors">
  <label for="job_client_email">Email: </label>
</div>
<div class="field_with_errors">
  <input type="email" value="wrong email" name="job[client_email]" id="job_client_email">
</div>

# 原先
@field_error_proc = Proc.new{ |html_tag, instance|
  "<div class=\"field_with_errors\">#{html_tag}</div>".html_safe
}

# 重写后(当前也可以根据需求自己改造)
config.action_view.field_error_proc = Proc.new { |html_tag, instance|
  html_tag
}

group :development do
  gem 'capistrano'
  gem 'capistrano-bundler'
  gem 'capistrano-rails'
  gem 'capistrano-rvm'
end

group :production do
  # puma 是一个 Gem,服务器不需要安装其他的
  gem 'puma
end

$ cap install

require 'capistrano/setup'
require 'capistrano/deploy'
require 'capistrano/rvm'
require 'capistrano/bundler'
require 'capistrano/puma'
require 'capistrano/rails/assets'
require 'capistrano/rails/migrations'

Dir.glob('lib/capistrano/tasks/*.rake').each { |r| import r }

# config valid only for current version of Capistrano
lock '3.4.0'

set :application, 'xgroup'
set :repo_url, 'git@github.com:linjunzhugg/xx.git'

set :deploy_to, '/mnt/xgroup'

set :scm, :git

# Default value for :linked_files is []
set :linked_files, %w{config/database.yml config/oauth2.yml config/redis.yml config/secrets.yml}

# Default value for linked_dirs is []
set :linked_dirs, %w{bin log tmp/pids tmp/cache tmp/sockets vendor/bundle}

set :keep_releases, 5

namespace :deploy do

  after :restart, :clear_cache do
    on roles(:web), in: :groups, limit: 3, wait: 10 do
      # Here we can do anything such as:
      # within release_path do
      #   execute :rake, 'cache:clear'
      # end
    end
  end

  after :finishing, 'deploy:cleanup'

end

# Simple Role Syntax

set :rvm_type, :user
set :rvm_ruby_string, 'ruby-2.2.1'

set :branch, "master"

server '0.0.0.0', user: 'deployer', roles: %w{app}

# 针对 puma 的配置
set :puma_rackup, -> { File.join(current_path, 'config.ru') }
set :puma_state, "#{shared_path}/tmp/pids/puma.state"
set :puma_pid, "#{shared_path}/tmp/pids/puma.pid"
set :puma_bind, "unix://#{shared_path}/tmp/sockets/puma.sock"    #accept array for multi-bind
set :puma_conf, "#{shared_path}/puma.rb"
set :puma_access_log, "#{shared_path}/log/puma_error.log"
set :puma_error_log, "#{shared_path}/log/puma_access.log"
set :puma_role, :app
set :puma_env, fetch(:rack_env, fetch(:rails_env, 'production'))
set :puma_threads, [0, 120]
set :puma_workers, 0
set :puma_worker_timeout, nil
set :puma_init_active_record, false
set :puma_preload_app, true

# 最终会创建 shared/puma.rb，将配置写进去，然后调用

# Disable serving static files from the `/public` folder by default sinc
# Apache or NGINX already handles this.
config.serve_static_files = ENV['RAILS_SERVE_STATIC_FILES'].present

# important!!!
# 在 production.rb 有这么个配置，决定服务器是否伺服静态文件，默认服务器没设这个变量，因此为 false, 默认不伺服静态文件

upstream xgroup {
   server unix:/mnt/xgroup/shared/tmp/sockets/puma.sock;
}

server {
  listen 80;
  server_name xx
  root /mnt/xgroup/current/public

  # 由于服务器不伺服静态文件，所以自己需要手动配置
  location ~* /assets/ {
    gzip_static on;
    expires max;
    add_header Cache-Control public;
  }

  location / {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_redirect off;
    proxy_pass http://xgroup;
  }

}

# 也可以这么做：

upstream xgroup {
   server unix:/mnt/xgroup/shared/tmp/sockets/puma.sock;
}

server {
  listen 80;
  server_name xx
  root /mnt/xgroup/current/public

  # 先去访问机器上对应的路径文件，访问不了再去 @xgroup
  # 如果不加这句，会访问不了静态文件  
  try_files $uri/index.html $uri @xgroup;
  location @xgroup {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_redirect off;
    proxy_pass http://xgroup;
  }

}

Content-Type:multipart/form-data; boundary=----WebKitFormBoundaryrGKCBY7qhFd3TrwA

------WebKitFormBoundaryrGKCBY7qhFd3TrwA
Content-Disposition: form-data; name="text"

title
------WebKitFormBoundaryrGKCBY7qhFd3TrwA
Content-Disposition: form-data; name="file"; filename="chrome.png"
Content-Type: image/png

PNG ... content of chrome.png ...
------WebKitFormBoundaryrGKCBY7qhFd3TrwA--

# Rails 会自动处理 Accept 以及 .json 两种情况
respond_to do |format|
  format.html { redirect_to groups_url }
  format.json
end

resources :users, defaults: {format: :json}

Accept: application/json,text/plain, */*;

 def format(view_path = [])
   formats.first || Mime::NullType.instance
 end

 def formats
   fetch_header("action_dispatch.request.formats") do |k|
     params_readable = begin
                         parameters[:format]
                       rescue ActionController::BadRequest
                         false
                       end

     v = if params_readable
       Array(Mime[parameters[:format]])
     elsif use_accept_header && valid_accept_header
       accepts
     elsif extension_format = format_from_path_extension
       [extension_format]
     elsif xhr?
       [Mime[:js]]
     else
       [Mime[:html]]
     end
     set_header k, v
   end
 end

 # 这里一旦匹配到  ,*/* | */*, 就会忽视掉整个 Accept 了。
 BROWSER_LIKE_ACCEPTS = /,\s*\*\/\*|\*\/\*\s*,/

def valid_accept_header # :doc:
    (xhr? && (accept.present? || content_mime_type)) ||
       (accept.present? && accept !~ BROWSER_LIKE_ACCEPTS)
end