CSRF 的全名是 Cross Site Request Forgery，翻译成中文就是跨站点请求伪造

CSRF 利用的是网站对用户网页浏览器的信任，简单地说，是攻击者通过一些技术手段欺骗用户的浏览器去访问一个自己曾经认证过的网站并运行一些操作（如发邮件，发消息，甚至财产操作如转账和购买商品）。
由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去运行。这利用了 web 中用户身份验证的一个漏洞：简单的身份验证只能保证请求发自某个用户的浏览器，却不能保证请求本身是用户自愿发出的

例子：

假如一家银行用以运行转账操作的 URL 地址如下：https://bank.example.com/withdraw?account=AccoutName&amount=1000&for=PayeeName

那么，一个恶意攻击者可以在另一个网站上放置如下代码：<img src="https://bank.example.com/withdraw?account=Alice&amount=1000&for=Badman" />

如果有账户名为 Alice 的用户访问了恶意站点，而她之前刚访问过银行不久，登录信息尚未过期，那么她就会损失 1000 资金

常见的防御手段

验证码

CSRF 攻击往往是在用户不知情的情况下伪造了请求，而验证码强制用户必须进行交互

• 措施：给敏感操作添加验证码校验
• 局限：影响用户体验

检查 Referer 字段

在处理敏感请求时，通常发出请求的网址应该与接受请求的网址属于同一域名

• 措施：所以我们可以通过校验 HTTP headers 中的 Referer 字段是否是属于本网站，如果不是则可能遭受 CSRF 攻击
• 局限：这种办法简单易行，工作量低，但是依赖于浏览器的发送正确的 Referer 字段，无法保证浏览器没有安全漏洞影响 Referer 的发送

不使用 GET 请求做敏感操作

在上面的例子中，我们可以知道，Alice 打开恶意站点后，浏览器通过 img 标签向银行转账网址发送了 GET 请求从而实现了 CSRF 攻击。

• 措施：所以，避免 CSRF 攻击最基础的一条是 永远不使用 GET 请求做敏感操作
• 局限：这种方法可以避免 img、script、iframe 等带 src 属性的标签发起 CSRF 攻击。但是无法防止攻击者构建 POST 请求等发起 CSRF 攻击

使用 Anti-CSRF-Token

CSRF 为什么能够攻击成功？其本质原因是重要操作的所有参数都是可以被攻击者猜测到的。攻击者只有预测出 URL 的所有参数与参数值，才能成功地构造一个伪造的请求；反之，攻击者将无法攻击成功。

• 措施：所以我们可以生成一个足够随机的参数 Token 放入该次请求，保证该次请求无法被攻击者成功伪造。

  核心思路：使用一个由服务器派发的 Token，在前端进行状态修改时，也同时提交这个 Token（往往会放在 html form 的 input 中，或者 ajax header 中），这时候服务端验证该 Token 是否是之前所生成的，以此来判断这个请求是否被允许

• 局限：

  1. 依赖于 Token 足够随机
  2. 无论是 Token 放在哪里，只要 JS 能读取到，都会面临 XSS 风险

在常见的 Web 后端框架比如 Rails、Django 中都自带实现了 csrf_token 功能，不同的是

• Rails 使用 meta 标签存放 csrf_token，通过 HTTP headers 发送
• Django 使用隐藏的 input 标签存放 csrf_token，通过 POST body 发送

前后端分离带来的问题

在现在大前端时代，前端后分离是个再常见不过的情况，我们该如何在前后端分离的情况下防止 CSRF 攻击呢？

首先，我们分析下上面所提到的几种手段在前后端分离下发生了什么变化：

• 验证码：
  • form 表单完全由前端生成，后端是无法感知的，即使前端使用某种方式在 form 中放入了验证码，但是后端也无法验证
• 检查 Referer 字段：无变化
• 不使用 GET 请求做敏感操作：无变化
• 使用 Anti-CSRF-Token：
  • form 表单完全由前端生成，后端是无法感知的，即使前端使用某种方式在 form 中放入了 Token，但是后端也无法验证

所以根本上是前后端分离之后，后端无法控制 form 生成时机，而前端则必须通过某种方式获取到由后端生成的 验证码 或者 Token 才能保证后端能够校验请求

• 措施：
  1. 后端引入安全模块，可能是写在 WAF 里，也有可能是 Security Sidecar 或者自定义的 API Gateway
  2. 前端请求安全模块，由安全模块生成 csrf_token 并返回，在提交时验证请求
• 局限：依然无法避免 XSS 攻击

XSRF

CSRF 的 Token 仅仅用于对抗 CSRF 攻击，当网站还同时存在 XSS 漏洞时，这个方案就会变得无效。
因为 XSS 可以模拟客户端浏览器执行任意操作，在 XSS 攻击下，攻击者完全可以请求页面后，读出页面内容里的 Token 值，然后再构造出一个合法的请求。这个过程就被称之为 XSRF

XSS 带来的问题，应该使用 XSS 的防御方案予以解决，否则 CSRF 的 Token 防御就是空中楼阁。安全防御的体系是相辅相成、缺一不可的

迷思

• Q：以下攻击能成功吗？

  1. 攻击者构建了一个恶意网站
  2. 恶意网站先通过请求上述所说的安全模块获取 csrf_token
  3. 恶意网站构造隐藏的 form 表单并对参数进行伪造
  4. 利用 JS 自动提交（恶意网站是攻击者所有，所以绕过了 XSS 防御策略） form 并携带 csrf_token 给目标网站

  A：不会，因为浏览器的 同源策略 不允许恶意网站获取安全模块所返回的结果（csrf_token），所以攻击在第 2 步时就会失败

参考

白帽子讲Web安全

跨站请求伪造

CSRF - 前后端分离后带来的新问题

因为需要在微博关注一些财经博主的更新，但又不想登录微博，遂研究了如何构建自己的 rss 平台，汇总感兴趣的信息。并使用 telegram 作为 rss 阅读器。

Install

1. 安装 RSSHub 作为 rss 平台

   mkdir rsshub
   cd rsshub
   wget https://raw.githubusercontent.com/DIYgod/RSSHub/master/docker-compose.yml
   docker volume create redis-data
   docker compose up -d

   更新

   docker compose down && docker compose pull && docker compose up -d

2. 安装 RSS-to-Telegram-Bot 以便从 telegram 上订阅 rss

   mkdir rsstt
   cd rsstt
   wget https://raw.githubusercontent.com/Rongronggg9/RSS-to-Telegram-Bot/dev/docker-compose.yml.sample -O docker-compose.yml
   vi docker-compose.yml  # fill in env variables
   docker compose up -d

   更新

   docker compose down && docker compose pull && docker compose up -d

Setup

有三种使用方式

1. 直接使用 Bot 订阅所有 rss
2. 将 Bot 添加到频道中，然后在频道中订阅 rss
   1. 创建一个公开频道，并输入 《频道名》，比如 test_rss_hub
      
   2. 将 Bot 添加到频道中
   3. 私聊 Bot 发送 /user_info @频道名，比如 /user_info @test_rss_hub
   4. 出现如下选项，点击 将用户状态设置为“用户”
      
3. 将 Bot 添加到群组中，然后在群组中订阅 rss
   1. 步骤与添加至频道类似

Tips: 必须先将频道/群组设置为 public，这样才能设置 Bot 发送到指定频道/群组。如果需要私有频道/群组，只需要在设置完成将频道/群组转为 private 即可。

点击去官网下载

激活

Registered Name: https://zhile.io
License Key: 48891cf209c6d32bf4

开启 http 调试

1. 点击菜单栏 Proxy -> Proxy Settings
2. 填写 Port
3. 勾选 Enable transparent HTTP proxying

开启抓取 macOS 请求

1. 点击菜单栏 Proxy -> Proxy Settings
2. 点击 macOS
3. 勾选 Enable macOS proxy
4. 勾选 Use HTTP proxy

开启抓取 Android 请求

手机连接局域网下 wifi，与 charles 必须为同一网络下。

1. 自动开启代理

   1. 在已连接的 wifi 上点击更多，进入配置代理页。

   2. 勾选自动，在输入框URL中输入：

      Https://chls.pro/10.10.11.235:6666.pac

2. 手动设置代理

   1. 在已连接的 wifi 上点击更多，进入配置代理页。
   2. 勾选手动，输入 charles 的 ip 与端口（ip 为 macOS 主机 ip，端口为上面填写的 http 端口）

设置 https

1. 点击 Proxy -> SSL Proxying Settings
   
2. 勾选 Enable SSL Proxying
3. 点击 Add，Host 填写 *，Port 填写 443
   

macOS 安装证书

1. 点击菜单栏 Help -> SSL Proxying -> Install Charles Root Certificate
   
2. 找到 Charles Proxy..... 并点击
3. 点击 Trust -> When using this certificate，并勾选 Always Trust
   

Android 安装证书

Android7 以后，系统不再信任用户级的证书，只信任系统级的证书，所以要抓包就需要把我们的 charles 证书安装至 Android 的系统目录中

准备

1. 一台已 root 的手机
2. Openssl

证书生成

1. 将 Filddler 或者其他抓包程序的证书导出，一般为 xxx.cer 或者 xxx.pem

2. 使用 openssl 的 x509 指令进行 cer 证书转 pem 证书 和 用 md5 方式显示 pem 证书的 hash 值

   # 1. 证书转换，已经是 pem 格式的证书不需要执行这一步
   openssl x509 -inform DER -in xxx.cer -out cacert.pem
   
   # 2. 进行 MD5 的 hash 显示
   
   # openssl 版本在 1.0 以上的版本的执行这一句
   openssl x509 -inform PEM -subject_hash_old -in cacert.pem
   
   # openssl 版本在 1.0 以下的版本的执行这一句
   openssl x509 -inform PEM -subject_hash -in cacert.pem

   将第二条指令输出的类似 347bacb5 的值进行复制
   tips：查看 openssl 版本的指令 openssl version

3. 将 pem 证书重命名
   使用上面复制的值（类似于 347bacb5）对 pem 证书进行重命名

   mv cacert.pem 347bacb5.0

4. 将新证书放入手机系统证书目录(/system/etc/security/cacerts)

   需要拷贝至此目录必须拥有 root 权限

5. 重启 Android 设备以生效
   拷贝证书至 /system/etc/security/cacerts 之后，重启手机就可以使证书生效了

参考

charles 安装配置 for Mac

给 Android7 及以上的手机安装系统级证书，实现 Fiddler 或者其他程序的 HTTPS 的抓包

今天对自己的项目做前后端联调时，发现在 mac 的 chrome 下（未测试 windows）没有自动过期 expires 为 session 的 cookie，对此感到一些疑惑

尝试

在网上搜索的时候，发现了 这篇文章，遂按照网友的解决方案，尝试了如下行为：

1. 点击作左上角 x，结果：无效
2. Command + Q 退出，结果：无效
3. 右键 Chrome 图标退出，结果：无效

很难受，网友提供的方法都无效

解决

1. 点击 chrome 设置
2. 默认浏览器 -> 启动时 -> 取消勾选 继续浏览上次打开的网页，勾选其他两个选项

原因

为了增强用户体验，chrome 会在 继续浏览上次打开的网页 设置下，默认不删除会话 cookie

Cloudflare Tunnel 是一款隧道软件，可以快速安全地加密应用程序到任何类型基础设施的流量，让您能够隐藏你的web 服务器IP 地址，阻止直接攻击，从而专注于提供出色的应用程序。

相比于 frp 等做内网穿透，Cloudflare Tunnels 的优势是不需要一台额外的公网服务器转发，并且可以享受到 Cloudflare CDN 带来的便利。

使用 frp 做内网穿透的流程如下：

flowchart LR
  server[Frp Server]
  clients[Frp Clients]

User -->|http/https| server -->|http/https| clients

使用 Cloudflare Tunnels 做内网穿透的流程如下：

flowchart LR
  tunnels[Cloudflare CDN]
  clients[Original Clients]

User -->|http/https| tunnels -->|Cloudflare Tunnels|clients

前置条件

需要有一个由 Cloudflare 管理的域名

配置

1. 安装 cloudflared

   debian:

   apt install cloudflared

   或者下载最新版

   wget -q https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb -O cloudflared.deb && dpkg -i cloudflared.deb && rm cloudflared.deb

2. 登录 cloudflared

   cloudflared tunnel login

   随后会生成一个 ~/.cloudflared/cert.pem 文件用于后续授权

3. 创建一个隧道 tunnel

   cloudflared tunnel create <名字>

   随后会在 ~/.cloudflared/ 目录下出现一个 json 文件 [Tunnel-UUID].json，里面保存着运行这条隧道所需要的授权信息。

4. 创建一个配置文件，~/.cloudflared/tunnels/名字.yaml，并添加

   # 反代的源站地址
   url: http://localhost:8080
   tunnel: <Tunnel-UUID>
   credentials-file: /root/.cloudflared/<Tunnel-UUID>.json

   如果在上一步没有保存 UUID 信息，可以通过 cloudflared tunnel info 获取

5. 配置路由

   cloudflared tunnel route dns [名字或者 Tunnel-UUID] [想要绑定到的域名或其二级域名]

6. 启动 cloudflared

   cloudflared tunnel --config ~/.cloudflared/tunnels/名字.yaml run

之后就可以通过在第 5 步 设置的域名进行访问

范例

例如，创建一条隧道从公网访问家里的 clash dashboard(地址为 192.168.1.1:9090)，设置隧道名字为 clash，并将其绑定到 clash.example.com：

1. cloudflared tunnel login 授权

2. cloudflared tunnel create clash，假设输出 Tunnel-UUID 为 c91c37a3-3efd-47fb-af0d-e5676ac122b9

3. 将下面配置添加到 ~/.cloudflared/tunnels/clash.yaml

   url: http://192.168.1.1:9090
   tunnel: c91c37a3-3efd-47fb-af0d-e5676ac122b9
   credentials-file: /root/.cloudflared/c91c37a3-3efd-47fb-af0d-e5676ac122b9.json

4. cloudflared tunnel route dns clash clash.example.com 创建路由

5. cloudflared tunnel --config ~/.cloudflared/tunnels/clash.yaml run 启动隧道

此时，访问 clash.example.com 等同于内网访问 192.168.1.1:9090

配置 systemd service 自动启动

1. 在 /etc/systemd/system 目录下创建 service 配置文件 EXAMPLE.service

   [Unit]
   Description=Cloudflare Tunnel
   After=network.target
   StartLimitIntervalSec=0
   
   [Service]
   Type=simple
   Restart=always
   RestartSec=1
   User=root
   ExecStart=cloudflared tunnel --config /root/.cloudflared/tunnels/名字.yaml run
   
   [Install]
   WantedBy=multi-user.target

2. 启动服务

   systemctl enable EXAMPLE
   systemctl start EXAMPLE

可行的方式

1. raw.githack.com
2. 反代加速

首先说说第一种，raw.githack.com 确实可以加速 gist，而且可以加速 repo。
使用方式很简单

• 将 gist.githubusercontent.com 替换为 gistcdn.githack.com
  例：http://gistcdn.githack.com/jiz4oh/189ed96ca1607b3ddf07bd64bcb459cd/raw/trojan.json
• 将 raw.githubusercontent.com 替换为 rawcdn.githack.com
  例：https://rawcdn.githack.com/jiz4oh/vim/master/vimrc

但是这种方式有一点弊端，就是不方便发表永链，当首次访问时，githack 会将内容缓存在 cloudflare 长达一年。当链接内容变化时，不会及时刷新，只适合发布永久内容，或者分版本发布。

第二种方式就是我经过一段时间摸索并决定采用的方式

Cloudflare Workers

Workers 的工作原理就是最近几年火热的 serverless。网站管理员不再一定需要一个服务器，只需要将对应的 Function 托管在 Workers 上，当用户访问网站时就会执行对应的 Function，值得一提的是 Cloudflare Workers 本质上只支持 JS（其他语言通过编译成 js 来执行）。

前期准备

1. cloudflare 的帐号
2. 域名，并且托管到 cloudflare

创建 worker

1. 登录帐号到下图界面

   

2. 然后进入 Workers

   

3. 点击创建 worker

   

4. 这时候会进入如下界面

   

反代加速 gist 代码如下：

// 需要反代的地址
const upstream = 'gist.github.com'
// 反代地址的子路径
const upstreamPath = '/'
// 反代网站的移动端域名
const upstreamMobile = 'gist.github.com'

// 是否使用 https
const useHttps = true

// 禁止使用该 worker 的国家代码
const blockedRegion = ['KP', 'SY', 'PK', 'CU']

// 禁止使用该 worker 的 ip 地址
const blockedIp = ['0.0.0.0', '127.0.0.1']

// 是否关闭缓存
const disableCache = false
// 替换条件
const contentTypes = [
  'text/plain',
  'text/html'
]
// 反代网站中其他需要被替换的地址
const replaceDict = {
  '$upstream': '$workerDomain',
}

addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

/**
 * Respond to the request
 * @param {Request} request
 */
async function handleRequest(request) {
  const region = request.headers.get('cf-ipcountry') || '';
  const ip = request.headers.get('cf-connecting-ip');

  if (blockedRegion.includes(region.toUpperCase())) {
    return new Response('Access denied: WorkersProxy is not available in your region yet.', {
      status: 403
    });
  }

  if (blockedIp.includes(ip)) {
    return new Response('Access denied: Your IP address is blocked by WorkersProxy.', {
      status: 403
    });
  }

  const upstreamDomain = isMobile(request.headers.get('user-agent')) ? upstreamMobile : upstream;

  // 构建上游请求地址
  let url = new URL(request.url);
  const workerDomain = url.host;
  
  url.protocol = useHttps ? 'https:' : 'http';
  url.pathname = url.pathname === '/' ? upstreamPath : upstreamPath + url.pathname;
  url.host = upstreamDomain;

  // 构建上游请求头
  const newRequestHeaders = new Headers(request.headers);
  newRequestHeaders.set('Host', upstreamDomain);
  newRequestHeaders.set('Referer', url.protocol + '//' + workerDomain);

  // 获取上游响应
  const originalResponse = await fetch(url.href, {
    method: request.method,
    headers: newRequestHeaders
  })

  const connectionUpgrade = newRequestHeaders.get("Upgrade");
  if (connectionUpgrade && connectionUpgrade.toLowerCase() === "websocket") {
    return originalResponse;
  }

  let originalResponseClone = originalResponse.clone();

  // 构建响应头
  let responseHeaders = originalResponseClone.headers;
  let newResponseHeaders = buildResponseHeaders(responseHeaders);
  if (newResponseHeaders.get("x-pjax-url")) {
    newResponseHeaders.set("x-pjax-url", responseHeaders.get("x-pjax-url").replace("//" + upstreamDomain, "//" + workerDomain));
  }

  // 构建响应体
  let originalText;
  const contentType = newResponseHeaders.get('content-type');
  if (contentType != null) {
    const types = contentType.replace(' ','').split(';')
    if (types.includes('charset=utf-8')){
      for (let i of contentTypes) {
        if (types.includes(i)){
          originalText = await replaceResponseText(originalResponseClone, upstreamDomain, workerDomain);
          break
        }
      }
    }
  } else {
    originalText = originalResponseClone.body
  }

  return new Response(originalText, {
    status: originalResponseClone.status,
    headers: newResponseHeaders
  })
}

function isMobile(userAgent) {
  userAgent = userAgent || ''
  let agents = ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"];
  for (let v = 0; v < agents.length; v++) {
    if (userAgent.indexOf(agents[v]) > 0) {
      return true;
    }
  }
}

function buildResponseHeaders(originalHeaders) {
  const result = new Headers(originalHeaders);
  if (disableCache) {
    result.set('Cache-Control', 'no-store');
  }
  result.set('access-control-allow-origin', '*');
  result.set('access-control-allow-credentials', true);
  result.delete('content-security-policy');
  result.delete('content-security-policy-report-only');
  result.delete('clear-site-data');

  return result
}

async function replaceResponseText(response, upstreamDomain, workerDomain) {
  let text = await response.text()
  const placeholders = {
    "$upstream": upstreamDomain,
    "$workerDomain": workerDomain
  }

  for (let origin in replaceDict) {
    let target = replaceDict[origin]

    origin = placeholders[origin] || origin
    target = placeholders[target] || target

    const re = new RegExp(origin, 'g')
    text = text.replace(re, target);
  }

  return text;
}

然后点击部署，就可以通过 [project].[subdomain].workers.dev 绕墙访问 gist 了，理论上是可以反代所有网站的，如果有需求的话，各位请自行修改代码~

注：

1. project 是创建的 worker 的名称
2. subdomain 是注册 workers 是输入的名字

自定义域名（可选）

经过上面的步骤，我们已经可以使用类似于 test.baidu.workers.dev 这样的域名使用触发 worker 了。但是如果需要使用自定义域名代替上述域名的话，还需要额外设置

ps：刚开始我以为直接在 DNS 中 CNAME 到 workers.dev 就行，但是实际操作之后发现是不可以的。

例如我们需要配置一个 test.jiz4oh.com 域名来使用 worker

1. 配置 DNS 解析

   

2. 设置 worker 路由

   

   

3. 等待数分钟，此时就可以访问 test.jiz4oh.com 来使用 worker 了

图床相信经常写东西而且文章图文并茂的朋友多多少少都接触过

公共图床服务要不就是备案麻烦，要不就是免费不稳定

本文就是关于如何利用 Github+Jsdelivr 创建免费、大容量、高速的个人图床，并且利用 vscode+PicGo 实现图片自动上传

创建 GitHub 仓库

仓库名随意

生成 Token

1. 点击个人设置
   
2. 点击开发者设置
   
3. 点击个人令牌
   
4. 创建令牌
   
5. 保存命令
   

配置 PicGo

vocode 安装 PicGo

扩展搜索 picgo

配置

打开 vscode 设置

点开 扩展 => PicGo

具体配置：

1. 选择 github
2. 一般选择 master，如果不需要发布到其他分支不要更改
3. 存入 vscode 的链接地址
   • 使用 jsdelivr：https://cdn.jsdelivr.net/gh/红框5处内容
   • 使用 rawgithubcontent：https://raw.githubusercontent.com/红框5处内容/红框2处内容
4. 存入 GitHub 仓库的子文件夹，可为空
5. 仓库名，格式为 用户名/仓库名
6. 之前生成的 Github Token

使用中的问题

描述：jsdelivr 无法加速，显示 Package size exceeded the configured limit of 50 MB

问题原因：jsdelivr 对每一个 release 限制加速 50MB

解决方案：

1. 进入仓库
2. 创建 release
   
3. 创建 master 版本
   
4. 修改 PicGo 设置 Custom Url
   在最后面添加 @master 指定版本号
5. 修改被拒绝显示的链接，在仓库名后面添加 @master。之前 jsdelivr 加速成功的链接不受影响

安装 Hexo 脚手架

npm install -g hexo-cli

安装之后可以使用 hexo 对博客命令操作

1. 创建 blog：hexo init 文件夹
2. 创建文章：hexo new 文章名
3. 生成静态文件：hexo generate 简写：hexo g
4. 清除已生成缓存：hexo clean
5. 启动本地服务：hexo server 简写：hexo s
   默认监听 4000 端口
6. 部署：hexo deploy 简写：hexo d
7. 生成静态文件并部署：hexo g -d

创建博客

hexo init blog
cd blog
hexo g
hexo s

访问 http://localhost:4000 查看本地博客

配置 blog 部署 Github Pages

创建 github.io 仓库

输入仓库名，仓库名以用户名开头，以 github.io 结尾

修改部署文件

1. 创建成功后，打开刚刚使用 hexo init blog 命令生成的 blog 文件夹

2. 修改 _config.yml 文件
   
   repo 填入刚刚创建的 GitHub 仓库地址，建议填写 ssh 仓库地址，https 地址也可

3. 部署到 Github Pages

   # 清理缓存
   hexo clean
   # 部署
   hexo g -d

GitHub Actions 自动部署

创建 blog 仓库

创建另外一个 GitHub 私有仓库 blog，用来存放 hexo 项目并触发部署

创建 ssh 密钥

ssh-keygen -f .ssh/github-deploy-key

.ssh 文件夹下会有 github-deploy-key 和 github-deploy-key.pub 两个文件。

配置部署密钥

1. 打开 blog 仓库设置，Settings -> Secrets -> Add a new secret
   
   • 在 Name 输入框填写 HEXO_DEPLOY_KEY。
   • 在 Value 输入框填写 github-deploy-key 文件内容。
2. 打开 用户名.github.io 仓库设置，
   
   • 在 Title 输入框填写 HEXO_DEPLOY_PUB。
   • 在 Key 输入框填写 github-deploy-key.pub 文件内容。
   • 勾选 Allow write access 选项。

编写 GitHub Actions

在 hexo 博客文件夹下创建 .github/workflows/deploy.yml 文件，目录结构如下：

blog
└── .github
    └── workflows
        └── deploy.yml

编辑 deploy.yml 文件：

name: Deploy GitHub Pages

on:
  push:
    branches:
      - master

# 修改 GitHub 用户名及邮箱才能正确部署
env:
  GIT_USER: jiz4oh
  GIT_EMAIL: jiz4oh@gmail.com

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node-version: [ 10.x ]

    steps:
      - name: Checkout
        uses: actions/checkout@v2
        with:
          persist-credentials: false

      - name: Use Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v1
        with:
          node-version: ${{ matrix.node-version }}

      - name: Configuration environment
        env:
          HEXO_DEPLOY_PRI: ${{secrets.HEXO_DEPLOY_KEY}}
        run: |
          mkdir -p ~/.ssh/
          echo "$HEXO_DEPLOY_PRI" > ~/.ssh/id_rsa
          chmod 600 ~/.ssh/id_rsa
          ssh-keyscan github.com >> ~/.ssh/known_hosts
          git config --global user.name $GIT_USER
          git config --global user.email $GIT_EMAIL

      - name: Install dependencies
        run: npm i

      - name: Install hexo-cli
        run: npm i -g hexo-cli

      - name: Clean
        run: hexo clean

      - name: Build & Deploy
        run: hexo g -d

测试

在 hexo 博客文件夹下，执行

# 配置 git 账户
git config --global user.name 用户名
git config --global user.email 邮箱

git remote add origin BLOG仓库地址
git push --set-upstream origin master

博客搭建好之后，由于当时已经晚上12点了，并没有一鼓作气的开启评论系统，就一直拖到了现在。。。

今天终于想起来开启评论系统，在网上搜索了一下 hexo 的评论系统，有以下几个：

• gitment：基于 GitHub Issue 作为评论存储仓库，但是一直长时间无人维护
• gitalk：同 gitment 使用 Github Issue，且页面比 gitment 更精美
• disqus：界面好看，支持 Facebook、twitter、Google+ 等账号登陆，但是 需要科学上网
• valine：基于 LeanCloud 的无后端评论系统，支持匿名评论
• 来必力：韩国的评论系统，功能强大，支持多社交帐号登录，链接不太稳定，不支持匿名评论

对于我来讲，我更偏向于使用 gitalk 作为评论系统，省心~但是 gitalk 类的评论系统被反馈有安全风险，虽然是 GitHub 的锅，但是会对访客（还不是我。。。）的账户安全带来很大的不确定性，所以最终我还是选择了支持匿名评论的 Valine

注册 LeanCloud

Valine 是基于 LeanCloud 进行使用的，所以我们需要在 LeanCloud 进行注册

因为现在 LeanCloud 国内版要求备案域名，所以使用国际版

配置 LeanCloud

• 创建应用：
  
• 切换到存储页面：
  
• 【结构化数据】-【创建 class】
  
• 修改 ACL 的 write 权限，设置成下图效果
  
• 切换到【设置】
• 【安全中心】-【Web 安全域名】，输入博客会用到的域名，如 http://jiz4oh.com、https://jiz4oh.com
  
• 【应用 Keys】-【AppID】
  【应用 Keys】-【AppKey】
  这两个数据在下一步中使用（可点击后面的按钮快速复制）
  

配置 next

• 打开 next 的配置文件，如我是 _confg.next.yml，将下列代码复制进去，注意缩进

  valine:
    enable: true
    appId: # 拷贝上一步的 ID
    appKey: # 拷贝上一步的 Key
    placeholder: # Comment box placeholder
    avatar: mm # Gravatar style
    meta: [nick, mail, link] # Custom comment header
    pageSize: 10 # Pagination size
    lang: # Language, available values: en, zh-cn
    visitor: false # Article reading statistic
    comment_count: true # If false, comment count will only be displayed in post page, not in home page
    recordIP: false # Whether to record the commenter IP
    serverURLs: # When the custom domain name is enabled, fill it in here (it will be detected automatically by default, no need to fill in)
    enableQQ: false # Whether to enable the Nickname box to automatically get QQ Nickname and QQ Avatar
    requiredFields: [] # Set required fields: [nick] | [nick, mail]

安装

yarn add hexo-theme-next

设置使用 Next

1. 打开博客文件夹

2. 打开 _config.yml 文件

   theme: next

删除默认主题（可选）

删除 themes 文件夹

配置 Next

本配置文件基于 hexo-theme-next@^8.0.0

未经特殊注明，均为修改主题配置文件 _config.next.yml

创建配置文件

touch _config.next.yml

设置主题为 Gemini

scheme: Gemini

返回顶部显示在侧边栏

back2top:
  sidebar: true

显示阅读进度条

reading_progress:
  enable: true
  # 显示在底部
  position: bottom

显示加载进度条

pace:
  enable: true

侧边栏菜单展开所有

toc:
  expand_all: true

启用 local search

安装外部依赖：

yarn add hexo-generator-searchdb

编辑 _config.yml

search:
  path: search.xml
  field: post
  format: html
  limit: 10000

编辑 _config.next.yml

# Local search
local_search:
  enable: true

设置代码高亮

codeblock:
  copy_button:
    enable: true
  prism:
    light: prism-tomorrow
    dark: prism-tomorrow

添加版权声明

creative_commons:
  license: by-nc-sa
  sidebar: true
  post: true

修改建站时间

footer:
  since: 2020

开启彩色缎带

canvas_ribbon:
  enable: true

开启文章字数统计

安装外部依赖：

yarn add hexo-word-counter

编辑 _config.yml

symbols_count_time:
  symbols: true
  time: true
  total_symbols: true
  total_time: true
  exclude_codeblock: false
  # 平均字长，默认为 4，中文为 2
  awl: 2
  wpm: 275
  suffix: "mins."

开启文章阅读量统计

busuanzi_count:
  enable: true

添加 GitHub Banner

github_banner:
  enable: enable
  permalink: https://github.com/jiz4oh
  title: Follow me on GitHub

删除不必要文件

minify: true

添加标签页面

命令行执行：

hexo new page tags

修改 source/tags/index.md

---
title: tags
date: 2020-09-26 12:51:57
# 添加下面两行
type: tags
comments: false
---

编辑 _config.next.yml

menu:
  tags: /tags/ || fa fa-tags

添加分类页面

命令行执行：

hexo new page categories

修改 source/tags/categories.md

---
title: categories
date: 2020-09-26 13:07:13
# 添加下面两行
type: categories
comments: false
---

编辑 _config.next.yml

menu:
  categories: /categories/ || fa fa-categories

设置字体

样式

font:
  enable: true
  global:
    external: true
    family: Arial
  # 以下设置只能修改 `` 注释的 md 代码块，不能修改 ```code block``` 字体大小
  # ```code block``` 字体大小修改见下
  # codes:
  #   external: true
  #   family: Arial
  #   size: 0.8

大小

编辑 _config.next.yml

custom_file_path:
  style: source/_data/styles.styl

新建 source/_data/styles.styl：

// 修改文章字体大小，强制保持 1em
div.post-body {
  font-size: 1em;
}

// 修改 code block 中的字体，需要写入以下样式
code[class*=language-] {
  font-size: 14px;
}

致谢

博客主题美化参考了诸多前辈的文章，感谢各位大神的无私分享~

参考文章

hexo的next主题个性化教程:打造炫酷网站

Next 原作者 iissnan 大神教程，v6 版本以上部分配置不适用

Next 社区教程

ehforwarderbot 是由 blueset 开源在 github 的一款专用于转发微信/QQ/Faceboot Message 到 Telegram 的机器人

ehforwarderbot 支持 多微信，多QQ 汇集到一起集中处理消息，特别适合：

1. Telegram 重度用户
2. 需要对多个微信、qq 消息进行处理的用户

最新版的 ehforwarderbot 已更新到 v2.0.0，本教程仅适用于 v1 版本，且 v2 版本与 v1 版本的数据库结构大改，无法从 v1 无缝迁移到 v2 版本。请谨慎安装 v1 版本

优点

1. 消息云同步，⽂字，语⾳，图⽚，视频，发送的链接，⽂件都可以保存在 tg 云端
2. 消息⼏乎⽆延迟，对⽐ Gcmformojo，tg 发消息很快，没有卡顿，就像你正常聊 tg ⼀样，也没有消息发送失
   败的情况（除⾮你⽹络没连上）
3. 耗电，明显优于微信毒瘤。tg ⾃带 gcm，如果你需要，可以不留 tg 后台，由 gcm 拉起通知
4. ⽆需挂梯，以往 Gcmformojo 有的地区需要挂飞机才能收发，⽽ tg ⾃带⼀个代理功能，可以通过代理收发微
   信
5. 公众号信息也能推送，⽽且 TG ⾃带应⽤内浏览器，也能⽅便的查看公众号推送的⽂章

缺点

ehforwarderbot 依赖于 web 版微信，所以 web 版微信没有的功能，它也不可能有，例如：

1. 无法收发红包
2. 无法查看别人分享的历史记录
3. 某些表情无法正常显示

安装 docker CE

卸载旧版本docker

sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

添加依赖

sudo yum update
sudo yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2

添加 Docker 稳定版本的 yum 软件源

sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

安装 docker

sudo yum update
sudo yum install docker-ce

docker开机自启：
sudo systemctl enable docker
启动docker服务：
sudo systemctl start docker

安装efb

创建配置文件

获取 Telegram Bot Token

1. 在Telegram关注@BotFather
2. 再到对话框依次输入：/start => /newbot
3. 然后会要你给机器人命名(如：TestBot)
4. 命名完成会得到 Token。

获取自己的 Userid

1. 先和你的机器人聊天，随便发一句话。
2. 在浏览器输入 https://api.telegram.org/botxx:xx/getUpdates(其中xx:xx为Token)
3. 然后 chat 后面的 id 即为你的 Userid。

创建 config

创建 config.py 文件

master_channel = 'plugins.eh_telegram_master', 'TelegramChannel'
slave_channels = [('plugins.eh_wechat_slave', 'WeChatChannel')]

eh_telegram_master = {
    "token": "机器人的 TOKEN",
    "admins": [你自己的 Userid],
    "bing_speech_api": ["3243f6a8885a308d313198a2e037073", "2b7e151628ae082b7e151628ae08"],
    "baidu_speech_api": {
        "app_id": 0,
        "api_key": "3243f6a8885a308d313198a2e037073",
        "secret_key": "2b7e151628ae082b7e151628ae08"
    }
}

创建 tgdata.db

创建 tgdata.db 文件，该文件可以为空

启动 ehforwarderbot

将 config.py 和 tgdata.db 放在 /root 目录下

运行：

docker run -d --restart=always --name=efb \
    -v /root/config.py:/opt/ehForwarderBot/config.py \
    -v /root/tgdata.db:/opt/ehForwarderBot/plugins/eh_telegram_master/tgdata.db \
    royx/docker-efb

登录 efb

docker logs efb

此时屏幕上会出现二维码，使用手机扫码登录即可

安装依赖

yum install -y gcc file-devel libwebp-tools git screen

# 安装 python3.6 和 pip3
wget https://www.moerats.com/usr/shell/Python3/CentOS_Python3.6.sh && sh CentOS_Python3.6.sh
yum install python3-pip python3-dev python3-setuptools

# 下载 ffmpeg
wget https://www.moerats.com/usr/down/ffmpeg/ffmpeg-git-$(getconf LONG_BIT)bit-static.tar.xz && tar xvf ffmpeg-git-*-static.tar.xz
mv ffmpeg-git-*/ffmpeg ffmpeg-git-*/ffprobe /usr/bin/
rm -rf ffmpeg-git-*

安装 efb

安装 efb（ehforwarderbot）

二选一：

# 安装稳定版
pip3 install ehforwarderbot

# 安装开发版
pip3 install git+https://github.com/blueset/ehforwarderbot.git

安装 ETB（efb-telegram-master）和 EWS（efb-wechat-slave）

# 安装TG和微信模块
pip3 install efb-telegram-master efb-wechat-slave

配置 efb

配置 efb（ehforwarderbot）

mkdir -p ~/.ehforwarderbot/profiles/default
vi ~/.ehforwarderbot/profiles/default/config.yaml

保存下列代码到 config.yaml：

master_channel: "blueset.telegram"
slave_channels:
- "blueset.wechat"

这只是登录一个微信号，如果你要同时登录多个微信号，那么配置文件就需要改为：

# 比如我要同时登录并收发3个微信号
master_channel: blueset.telegram
slave_channels:
- blueset.wechat
- blueset.wechat#moe123
- blueset.wechat#rats321
# #号后面指定id，只能是字母、数字、下划线

配置 ETB

# 同样的也建在 default 文件夹，如果你上面更改了 default 文件夹，那这里也要更改
mkdir ~/.ehforwarderbot/profiles/default/blueset.telegram
vi ~/.ehforwarderbot/profiles/default/blueset.telegram/config.yaml

保存下列代码到 blueset.telegram/config.yaml：

token: "机器人的 TOKEN"
admins:
- 你自己的 Userid
flags:
    # 关闭自动语言设置，使用 systemd 启动时默认中文
    auto_locale: false

配置 EWS

# 同样的也建在 default 文件夹，如果你上面更改了 default 文件夹，那这里也要更改
mkdir ~/.ehforwarderbot/profiles/default/blueset.wechat
vi ~/.ehforwarderbot/profiles/default/blueset.wechat/config.yaml

保存下列代码到 blueset.wechat/config.yaml：

flags:
    # tg 端编辑消息时以撤回并重新发送的方式发送到微信
    delete_on_edit: true
    # 每当请求会话列表时，强制刷新会话列表
    refresh_friends: true
    # 使用 iTerm2 图像协议 显示二维码。本功能只适用于 iTerm2 用户
    imgcat_qr: true
    # 在收到第三方合作应用分享给微信的链接时，其附带的预览图将缩略图上传到 sm.ms
    app_shared_link_mode: upload

设置守护进程

创建 efb 服务

vi /etc/systemd/system/efb.service

保存以下配置到 efb.service：

[Unit]
Description=EH Forwarder Bot instance
After=network.target
Wants=network.target
Documentation=https://github.com/blueset/ehForwarderBot

[Service]
Type=simple
Environment='LANG=zh_CN.UTF-8' 'PYTHONIOENCODING=utf_8' 'EFB_DATA_PATH=/root/.ehforwarderbot'
ExecStart=/usr/local/bin/ehforwarderbot --verbose
Restart=on-abort
KillSignal=SIGINT

[Install]
WantedBy=multi-user.target

使用 systemctl 管理 efb

# 开机启动
sudo systemctl enable efb

# 启动
sudo systemctl start efb

# 关闭
sudo systemctl stop efb

# 重启
sudo systemctl restart efb

# 查看运行详情
sudo systemctl status efb

# 查看更加详细的运行详情
sudo systemctl status efb -l

登录 efb

• 如果不使用 systemctl 管理，则执行 ehforwarderbot --verbose 进行启动
• 如果使用 systemctl 进行管理
  1. sudo systemctl start efb
  2. sudo systemctl status efb -l 然后复制二维码连接到浏览器，扫码登陆

安装中遇到的错误

缺少 cairo 依赖

描述：

raise OSError(error_message) # pragma: no cover
OSError: no library called "cairo" was found

解决方案：

yum install -y cairo-devel libtiff* && pip3 install cairosvg cairocffi

描述：

Command "python setup.py egg_info" failed with error code 1 in /tmp/pip-build-g3q2qdl8/cairocffi/

原因：pip 版本过低

解决方案：

pip3 install --upgrade pip

python 安装失败

描述：

configure: error: in `/usr/local/src/Python-3.6.4':
configure: error: no acceptable C compiler found in $PATH
See `config.log' for more details

解决方案：
yum install gcc -y

描述：

zipimport.ZipImportError: can't decompress data; zlib not available
make: *** [install] Error 1

解决方案：
yum install zlib* -y

pip 安装依赖失败

描述：
install --record /tmp/pip-f5erwx9h-record/install-record.txt --single-version-externally-managed --compile" failed with error code 1 in /tmp/pip-build-34xxo8de/cairocffi/

解决方案：

pip install -U setuptools
pip install -U wheel

如何迁移

1. 保留 /root/.ehforwarderbot/profiles/default/blueset.telegram 下的 config.yaml 和 tgdata.db 文件
2. 保留 /root/.ehforwarderbot/profiles/default/blueset.wechat 下的 wxpy_puid.pkl 文件（这个文件存着对应微信好友的 UID，与 tgdata 的 chatassoc 表相对应）

出于对国产输入法软件的不信任，再加上国产输入法广告太多等因素的影响，促使我想要尽快找到一个开源、快捷、不自动上传云端的输入法。

在网上搜索时，Rime 收到了一致好评，让我萌生了非常大的兴趣，故特意找到了 Rime 的相关资料并整理。

本文基于 Rime v1.5.3 版本进行整理，其他版本可能不适用。

关于 Rime

什么是 Rime

Rime 全名是「中州韵输入法引擎」，Rime 不是一种输入法。是从各种常见键盘输入法中提炼出来的抽象的输入算法框架，由 佛振 大佬开发。
Rime 通过各种输入方案来实现对几乎所有中文的支持，包括但不限于【拼音】、【注音】、【双拼】、【五笔】、【仓颉】，并且可以简单的进行【简繁】的切换

什么是输入方案

Rime 由于本质只是一个框架，本身是不知道如何输入的。
如果我们想要使用 Rime，就得定义一些关于如何输入的设置来告诉 Rime，这些设置就是输入方案。

Rime 的版本

Rime 是一个天生跨平台的框架，在每一个平台都有对应的发行版本：

1. Linux：
   • 官方：ibus-rime（中州韵）
   • 第三方：fcitx-rime
2. windowns：
   • 官方：Weasel（小狼毫）
   • 第三方：PRIME
3. macOS：
   • 官方：Squirrel（鼠须管）
   • 第三方：XIME
4. Android：
   • 第三方：Trime（同文）
5. iOS：
   • 第三方：iRime

上面是 Rime 在各平台对应的软件，Rime 默认提供了两个拼音输入方案「朙月拼音」和「地球拼音」，两者都可以输入准确的繁体和简体，而且「地球拼音」还支持声调输入。
Rime 还支持了许多种方言拼音，如吴语、粤语，甚至中古汉语。

Rime 的文件架构

Rime 所有的配置文件、输入方案及词典文件，均是普通的文本文档，均要求 UTF8 编码。
其中配置文件、输入方案要求使用 yaml 格式的文件。词典文件使用普通的 txt 文档即可。

Rime 中将文件分为 共享文件夹 和 用户文件夹。

• 共享文件夹 中存放的是 Rime 发行版的默认文件，一般是不允许进行修改的
  • 【中州韵 ibus-rime】 /usr/share/rime-data/
  • 【小狼毫 Weasel】 安装目录\data
  • 【鼠须管 Squirrel】 /Library/Input Methods/Squirrel.app/Contents/SharedSupport/
• 用户文件夹 的存放位置
  • 【中州韵 ibus-rime】 ~/.config/ibus/rime/
  • 【小狼毫 Weasel】 %APPDATA%\Rime，也可以通过“开始菜单＼小狼毫输入法＼用户文件夹”打开。
  • 【鼠须管 Squirrel】 ~/Library/Rime/，也可以通过“系统输入法菜单／鼠须管／用户设置”打开。

用户文件夹

刚开始安装后，在 用户文件夹 中是没有文件的，当我们运行 Rime 后会出现以下文件/文件夹：

• build/*：这个文件夹下存放的是我们每次部署之后生成的静态文件
  • <输入方案名>.prism.bin：Rime 棱镜，拼写运算规则
  • <词典名>.table.bin：Rime 固态词典，按音节编码检索词条的索引
  • <词典名>.reverse.bin：Rime 反查词典，按词条检索编码的索引
• <词典名>.userdb/*：这个文件夹是我们的词典文件夹，当我们进行了输入之后，会将输入的内容存入，以便进行词语调频
• installation.yaml：这个文件是关于我们本机 Rime 的安装时间、版本信息等
• user.yaml：这个文件是关于 Rime 的一些设置选项，比如我们上次选择的输入方案

Rime 的配置文件都需要放于 用户文件夹 下，分为三类：

• default.yaml：全局配置，存放跨输入方案的通用配置
• <输入方案名>.schema.yaml：存放某一个输入方案的配置
  如：double_pinyin_flypy.schema.yaml
• <发布版名>.yaml：存放某个发行版的独有配置
  如：symbols.yaml

如果有其他额外文件，也需要放入 用户文件夹 下，才能被配置文件正确使用

自定义 Rime 的全局配置

我的全局配置 default.custom.yaml

menu

可配置项：

• page_size：每页个数，默认 5，允许 1~9

该项可在每个输入方案中单独设置

示例：

menu:
  page_size: 8

schema_list

可配置项：

• schema：每一项 schema 对应一项方案的 schema_id

示例：

schema_list:
  - schema: luna_pinyin
  - schema: luna_pinyin_simp
  - schema: luna_pinyin_fluency
  - schema: bopomofo
  - schema: bopomofo_tw
  - schema: cangjie5
  - schema: stroke
  - schema: terra_pinyin

switcher

可配置项：

• caption：切换器被调用时屏幕显示的名字
• hotkeys：切换器调用的快捷键
• abbreviate_options：
• fold_options：
• option_list_separator：
• save_options：

示例：

switcher:
  abbreviate_options: true
  caption: "〔方案選單〕"
  fold_options: true
  hotkeys:
    - "Alt+Shift+Control+grave"
    - "Control+grave"
  option_list_separator: "／"
  save_options:
    - full_shape
    - ascii_punct
    - simplification
    - extended_charset
    - zh_hant
    - zh_hans
    - zh_hant_tw

自定义 Rime 的输入法方案

Rime 输入方案主要分为三部分

• schema：关于整个输入方案的信息阐述
• switches：可以切换的开关，比如切换全半角，切换简繁体
• engine：Rime 的核心配置，配置整个 Rime 是如何进行运作

特殊说明：

输入方案的某些细项设置是可以写在全局设置中，比如

• key_binder
• punctuator
• ascii_composer
• recognizer

在输入方案中设置 menu/page_size 是可以的

schema

可配置项：

• name：方案的显示名称〔即出现于方案选单中，通常为中文〕
• schema_id：方案内部名，在代码中引用此方案时的名称，通常由英文，数字，下划线组成
• author：方案作者。如果您对方案做出了修改，请保留原作者名，放入自己的名字加在后面
• description：简要描述方案历史，码表来源，该方案规则等
• dependencies：如果本方案依赖于其他方案〔通常来说会依赖其他方案做为反查，抑或是两种或多种方案混用时]
• version：版本号，在发布新版前请确保已升版本号

示例：小鹤双拼

schema:
  name: "小鶴雙拼"
  schema_id: double_pinyin_flypy
  author:
    - "double pinyin layout by 鶴"
    - "Rime schema by 佛振 <chen.sst@gmail.com>"
  description: |
    朙月拼音＋小鶴雙拼方案。
  dependencies:
    - stroke
  version: 0.18

switches

• ascii_mode：中英文切换开关。0 为中文，1 为英文

• full_shape：全角符号／半角符号开关。默认 0 为半角，1 为全角。注意，开启全角时英文字母亦为全角。

• extended_charset：字符集开关。0 为 CJK 基本字符集，1 为 CJK 全字符集。仅 table_translator 可用

• ascii_punct：中西文标点切换开关，0 为中文句读，1 为西文标点。

• simplification：是转化字开关。一般情況下与上同，0 为不开启转化，1 为转化。
  simplification 选项名称可自定义，亦可添加多套替換用字方案：

  - name: zh_cn
    states: ["漢字", "汉字"]
    reset: 0

  或

  - options: [ zh_trad, zh_cn, zh_mars ]
    states:
      - 字型 → 漢字
      - 字型 → 汉字
      - 字型 → 䕼茡
    reset: 0

  • name/options：須与 engine 中 simplifier 的 option_name 相同

    switches:
      - name: zh_simp
        reset: 1
        states: [ 漢字, 汉字 ]
    simplifier:
      option_name: zh_simp

  • states：可不写，如不写则此开关存在但不可见，可由快捷鍵操作

  • reset：设定开关默认状态〔若 reset 为空，则使用上次状态〕

• 字符集过滤。此选项沒有默认名称，須配合 charset_filter 使用。可單用，亦可添加多套字符集

示例：

switches:
  - name: ascii_mode
    reset: 0
    states: ["中文", "西文"]
  - name: full_shape
    states: ["半角", "全角"]
  - name: extended_charset
    states: ["通用", "增廣"]
  - name: simplification
    states: ["漢字", "汉字"]
  - name: ascii_punct
    states: ["句讀", "符號"]

engine

Rime 的核心原理是通过 enagine 下的 4 大组件对用户输入进行处理，4 大组件分别是：

• Processors
• Segmentors
• Translators
• Filters

整个流程为：

1. Processors 下的各个 processor 对用户的输入（即按下键盘的哪一个键）依次进行处理，将按键按照预设的规则对按键进行响应
   • 不处理：Rime 不对该按键做任何响应，使用系统默认操作
   • 特殊操作：比如 Enter 上屏，切换输入方案、组合键等
   • 输入候选：该按键是需要转换为文字的按键，比如 123abc，将该按键字符存入【输入码】上下文
2. 当【输入码】上下文改变时，Segmentors 下的 segmentor 会将当前输入码根据格式分段，各自打上标签。比如【朙月拼音】中，输入码 2012nian\，划分为三个编码段：2012（贴 number 标签）、nian（贴 abc 标签）、\（贴 punct 标签）。
3. 顾名思义，Translators 完成由编码到文字的翻译。但有几个要点：
   • 翻译的对象是划分好的一个代码段。
   • 某个 translator 组件往往只翻译具有特定标签的代码段。
   • 翻译的结果可能有多条，每条结果成为一个展现给用户的候选项。
   • 代码段可由几种 translator 分别翻译、翻译结果按一定规则合并成一列候选。
   • 候选项所对应的编码未必是整个代码段。用拼音敲一个词组时，词组后面继续列出单字候选，即是此例。
4. 翻译完成后，由 Filters 对所有翻译结果进行处理，比如去重

示例：

engine:
  processors:
    - ascii_composer
    - recognizer
    - key_binder
    - speller
    - punctuator
    - selector
    - navigator
    - express_editor
  segmentors:
    - ascii_segmentor
    - matcher
    - abc_segmentor
    - punct_segmentor
    - fallback_segmentor
  translators:
    - punct_translator
    - script_translator
    - "table_translator@custom_phrase"
  filters:
    - "simplifier@emoji_suggestion"
    - "simplifier@zh_simp"
    - uniquifier
    - single_char_filter

Processors

• ascii_composer：处理英文模式及中英文切换
• recognizer：与 matcher 搭配，处理符合特定规则的输入码，如网址，反查等
• key_binder：在特定条件下将按键绑定到其他按键，如重定义逗号，句号为预设翻页，开关快捷键等
  处理某些自定义的组合键
• speller：拼写处理器，接受字符按键，编辑输入
  处理自定义的键，通常为 26 个英文字母
• punctuator：句读处理器，将个别字符按键直接映射为标点符号或文字
  处理句读键、数字键
• selector：选字处理器
  处理数字键、上下方向键、PageUp、PageDown
• navigator：处理输入栏内的光标移动
  处理左右方向键、Home、End
• express_editor：编辑器
  处理空格、回车、回退键

不常用：

• fluid_editor：句式编辑器，用于以空格断开词，回车上屏的【注音】，【语句流】等输入方案，与 express_editor 互斥，也可以写作 fluency_editor
• chord_composer：和弦作曲家或曰并击处理器，用于【宫保拼音】等多键并击的输入方案
• lua_processor：使用 lua 自定义按键，后接 @lua函数名
  • lua 函数名即用户文件夹内 rime.lua 中函数名，参数为(key, env)

recognizer

可配置项：

• import_preset：从外部文件导入
• patterns：配合 segmentor 的 prefix 和 suffix 完成段落划分、tag 标记

示例：

recognizer:
  import_preset: default
  patterns:
    code: "[a-zA-Z]+(*$"
    email: "^[A-Za-z][-_.0-9A-Za-z]*@.*$"
    html: "^<[a-z]+>$"
    punct: "^/([a-z]+|[0-9]0?)$"
    uppercase: "[A-Z][-_+.'0-9A-Za-z]*$"
    url: "^(www[.]|https?:|ftp[.:]|mailto:|file:).*$|^[a-z]{1,10}[.:_-].*$"

key_binder

可配置项：

• import_preset：从外部文件导入
• bindings：设置组合键的映射
  每一条 binding 中包含字段：
  • accept：键盘输入的按键
  • when：作用条件
  • send：实际调用的按键
  • toggle：切换开关，和 send 不共存

accept 和 send 作用的键，需要输入 Ibus 风格的键名：

Mac 只支持 Alt/Option 键，不支持Command键，详见

Shift_L		左Shift
Shift_R		右Shift
Control_L	左Ctrl
Control_R	右Ctrl
Alt_L		左Alt
Alt_R		右Alt
# 在 windows 是 windows 键
Meta_L		左Meta
Meta_R		右Meta
Super_L		左Super
Super_R		右Super
Hyper_L		左Hyper
Hyper_R		右Hyper

BackSpace	退格
Tab			制表符
Caps_Lock	大写键
Linefeed	换行
Clear		清除
Return		回车
Pause		暂停
Escape		Esc退出
Delete		刪除
Home		Home
Left		左箭头
Up			上箭头
Right		右箭头
Down		下箭头
Prior		上翻
Page_Up		上翻
Next		下翻
Page_Down	下翻
space 		空格
Sys_Req	
End			末位
Begin		始位
Shift_Lock	上檔鎖
Scroll_Lock	滚动锁
Num_Lock	小键盘锁
Select		选择
Print		打印
Execute		执行
Insert		插入
Undo		还原
Redo		重做
Menu		菜单
Find		寻找
Cancel		取消
Help		帮助
Break		中断

grave			`
asciitilde		~
exclam			!
at				@
numbersign		#
dollar			$
percent			%
ampersand		&
asciicircum		^
asterisk		*
parenleft		(
parenright		)
underscore		_
minus			-
plus			+
equal			=
bracketleft		[
bracketright	]
braceleft		{
braceright		}
bar				|
slash			/
backslash		\
semicolon		;
colon			:
apostrophe		'
quotedbl		"
comma			,
period			.
less			<
greater			>
question		?

KP_Space		小键盘空格
KP_Tab			小键盘制表符
KP_Enter		小键盘回车
KP_Delete		小键盘刪除
KP_Home			小键盘原位
KP_Left			小键盘左箭头
KP_Up			小键盘上箭头
KP_Right		小键盘右箭头
KP_Down			小键盘下箭头
KP_Prior		小键盘上翻
KP_Page_Up		小键盘上翻
KP_Next			小键盘下翻
KP_Page_Down	小键盘下翻
KP_End			小键盘末位
KP_Begin		小键盘始位
KP_Insert		小键盘插入
KP_Equal		小键盘等于
KP_Multiply		小键盘乘号
KP_Add			小键盘加号
KP_Subtract		小键盘減号
KP_Divide		小键盘除号
KP_Decimal		小键盘小数点
KP_0			小键盘0
KP_1			小键盘1
KP_2			小键盘2
KP_3			小键盘3
KP_4			小键盘4
KP_5			小键盘5
KP_6			小键盘6
KP_7			小键盘7
KP_8			小键盘8
KP_9			小键盘9

示例：

key_binder:
  bindings:
    - {accept: minus, send: Page_Up, when: paging}
    - {accept: equal, send: Page_Down, when: has_menu}
    - {accept: bracketleft, send: Page_Up, when: paging}
    - {accept: bracketright, send: Page_Down, when: has_menu}
    - {accept: 9, send: Page_Up, when: paging}
    - {accept: 0, send: Page_Down, when: has_menu}
    - {accept: semicolon, send: 2, when: has_menu}
    - {accept: apostrophe, send: 3, when: has_menu}

speller

可配置项：

• alphabet：设置本 speller 需要监听的键
• initials：设置哪些键仅在开头的时候才需要监听
• finals：设置哪些键仅在末尾的时候才需要监听
• delimiter：分词符
• algebra：Rime 核心的拼写运算规则，所有 algebra 算出的规则最后写入 prism
• max_code_length：行码最大码長，超过则自动顶字上屏〔number〕
• auto_select：是否开启自动上屏〔true 或 false〕
• auto_select_pattern：自动上屏规则（正则），当输入码匹配正则时自动顶字上屏。
• use_space：空格是否可作为输入码〔true 或 false〕

punctuator

可配置项：

• import_preset：从外部文件导入
• half_shape：半角模式下的句读映射
  每条选项可以设置上屏模式
  • 默认：选项模式
  • commit：直接上屏
  • pair：交替上屏
• full_shape：全角模式下的句读映射
  同 half_shape 可设置上屏模式
• use_space：是否使用空格顶字〔true 或 false〕

示例：

punctuator:
  # 标点及特殊表情，引入 symbols 文件
  import_preset: symbols
  # 覆盖 symbols 文件对应 key
  symbols:
    "/dn": [⌘, ⌥, ⇧, ⌃, ⎋, ⇪, , ⌫, ⌦, ↩︎, ⏎, ↑, ↓, ←, →, ↖, ↘, ⇟, ⇞]
    "/fh": [ ©, ®, ℗, ℠, ™, ℡, ⓘ, ♂, ♀, ☉, ☊, ☋, ☌, ☍, ☐, ☑︎, ☒, ☜, ☝, ☞, ☟, ✎, ✄, ♲, ♻, ⚐, ⚑, ⚠]
    "/xh": [ ＊, ×, ✱, ★, ☆, ✩, ✧, ❋, ❊, ❉, ❈, ❅, ✿, ✲]
  half_shape:
    "`": "·"
    "~": "~"
    "@": "@"
    "#": "#"
    "$": ["¥", "$", "€", "£", "¢", "¤"]
    "%": "%"
    "^": "……"
    "*": ["*", "×", "·", "・", "※", "＊", "❂"]
    "_": "——"
    "=": "="
    '\': "、"
    "'":
      pair:
        - "‘"
        - "’"
    "|": "|"
    "(": "（"
    ")": "）"
    "[": "【"
    "]": "】"
    "{": "「"
    "}": "」"
    "<": "《"
    ">": "》"
    "/": ["/", "÷"]

Segmentors

• ascii_segmentor：标识英文段落〔例如在英文模式下〕字母直接上屛
• matcher：配合 recognizer 标识符合特定规则的段落，如网址，反查等，加上特定 tag
• abc_segmentor：标识常规的文字段落，加上 abc 这个默认tag
• punct_segmentor：标识句读段落〔键入标点符号用〕加上 punct 这个tag
• fallback_segmentor：标识其他未标识段落
• affix_segmentor：用户自定义 tag
  • 可加载多个实例，后接 @tag名

不常用：

• lua_segmentor 使用lua自定义切分，后接 @lua函数名

Translators

• table_translator：编码表翻译器，用于仓颉，五笔等基于编码表的输入方案
  • 可加载多个实例，后接 @翻译器名〔如：cangjie，wubi等〕
• script_translator：脚本翻译器，用于拼音，粤拼等基于音节表的输入方案
  • 可加载多个实例，后接 @翻译器名〔如：pinyin，jyutping等〕
• punct_translator：配合 punct_segmentor 转换标点符号
• echo_translator：没有其他候选字时，显示输入码〔输入码可以 Shift+Enter 上屛〕

不常用：

• reverse_lookup_translator：反查翻译器，用另一种种编码方案查码
• lua_translator：使用 lua 自定义输入，例如动态输入当前日期，时间，后接 @lua函数名
  • lua 函数名即用户文件夹内 rime.lua 中函数名，参数为(input, seg, env)
  • 可以 env.engine.context:get_option(“option_name”)方式绑定到 switch 开关／key_binder 快捷键

translator

每个输入方案有一个关于 translator 的全局设置，可设置项：

• dictionary：翻译器使用的字典名

• prism：设定此翻译器的 speller 生成的棱镜文件名，或此副编译器调用的棱镜名

• user_dict：设定用户词典名

• db_class：设定用户词典类型，可设 tabledb〔文本〕或 userdb〔二进制〕

• preedit_format：上屛码自定义

• comment_format：提示码自定义

• initial_quality：设定此翻译器结果优先级

• disable_user_dict_for_patterns：禁止某些编码录入用户词典〔true 或 false〕

• enable_sentence：是否开启自动造句〔true 或 false〕

• enable_user_dict：是否开启用户词典〔用户词典记录动态字词频，用户词〕〔true 或 false〕

仅 table_translator 生效：

• enable_charset_filter：是否开启字符集过滤〔cjk_minifier 启用后可适用于 script_translator〕〔true 或 false〕
• enable_encoder：是否开启自动造词〔true 或 false〕
• encode_commit_history：是否对已上屛词自动成词〔true 或 false〕
• max_phrase_length：最大自动成词词长〔number〕
• enable_completion：提前显示尚未输入完整码的字〔true 或 false〕
• sentence_over_completion：在无全码对应字而仅有逐键提示时也开启智能组句〔true 或 false〕
• strict_spelling：配合 speller 中的 fuzz 规则，仅以畧拼码组词〔true 或 false〕

仅 script_translator 生效

• spelling_hints：设定多少字以内部预定标注完整带调拼音

除了 translator 项设置，其他通过 @ 定义的副翻译器还可单独设置：

• tag：设定此翻译器针对的 tag。默认 abc
• prefix：设定此翻译器的前缀标识，默认无
• suffix：设定此翻译器的后缀标识，默认无
• tips：设定此翻译器的输入前提示符，默认无
• closing_tips：设定此翻译器的输入结束提示符，默认无

示例：

# tarnslator
translator:
  dictionary: luna_pinyin
  prism: luna_pinyin_simp
  preedit_format:
    - xform/([nl])v/$1ü/
    - xform/([nl])ue/$1üe/
    - xform/([jqxy])v/$1u/

# 副翻译器设置
custom_phrase: # 這是一個 table_translator
  dictionary: ""
  user_dict: custom_phrase
  db_class: tabledb
  enable_sentence: false
  enable_completion: false
  initial_quality: 1

词典与码表

translator 通过词典来翻译对应的片段，通常命名为 <词典名>.dict.yaml

词典：

• name：词典名，内部使用，可以与配套的输入方案名一致，也可不同；
• version：管理词典的版本；
• sort：词条初始排序方式，〔by_weight（按词频高低排序）或 original（保持原码表中的顺序）〕；
• use_preset_vocabulary：选择是否导入默认词汇表【八股文】〔true 或 false〕。

示例：

# 这里以 --- ... 分別标记出 YAML 文件的起始与结束位置
---
name: luna_pinyin
version: "0.9"
sort: by_weight
use_preset_vocabulary: true
# 在 ... 标记之后的部分就不会作为 YAML 文件來解析
...

码表，定义编码与文字的映射关系，通过制表符分割为三列：

• 文字
• 编码，如果该编码有多个音节，各音节以空格分开
• 权重，相同编码时出现在候选列表前面的几率

示例：

你	ni
我	wo
的	de	99%
的	di	1%
地	de	10%
地	di	90%
目	mu
好	hao

你我
你的
我的
我的天
天地	tian di
好天
好好地
目的	mu di
目的地	mu di di

Filters

• simplifier：简繁转换，表情转换等
  • 可加载多个实例，后接 @d转化器名〔如：zh_simp、emoji_suggestion 等〕
• uniquifier：过滤重复的候选字，有可能来自 simplifier
• reverse_lookup_filter：反查滤镜，以更灵活的方式反查，Rime1.0 后替代 reverse_lookup_translator
  • 可加载多个实例，后接 @滤镜名〔如：pinyin_lookup，jyutping_lookup 等〕
• charset_filter 字符集过滤
  • 后接 @字符集名〔如：utf-8（无过滤），big5，big5hkscs，gbk，gb2312〕
• lua_filter：使用 lua 自定义过滤，例如过滤字符集，调整排序，后接 @lua函数名
  • lua函数名即用户文件夹内rime.lua中函数名，参数为(input, env)
  • 可以env.engine.context:get_option(“option_name”)方式绑定到switch开关／key_binder快捷键

仅 script_translator：

• cjk_minifier：字符集过滤，使之支持 extended_charset 开关

仅 table_translator：

• single_char_filter：单字过滤器，如加载此组件，则屛敝词典中的词组

使用小鹤双拼

小鹤双拼原始配置文件：double_pinyin_flypy.schema.yaml

我的小鹤双拼配置 double_pinyin_flypy.schema.yaml

Mac 上如何使用 Squirrel

在 mac 上通常使用 homebrew 的方式安装 app

brew cask install squirrel

如果没有 homebrew，点击这里

Squirrel 设置项

Squirrel 配置项基于 0.14.0 整理

我的 suirrel 配置 squirrel.custom.yaml

特定程序操作 options

可配置项：

• ascii_mode：是否使用英文〔true 或 false〕
• vim_mode：config_version 0.34.0 启用，是否支持使用 ESC 键退出编辑模式并切换为英文〔true 或 false〕

示例：

options:
  com.apple.Xcode:
    ascii_mode: true

可视化的自定义皮肤

可视化编辑器

Android 上如何使用 Trime

正式版，点击下载

测试版，点击下载

我的 Trime 同文配置 jiz4oh.trime.yaml

基础设置

1. 启用输入法
   

2. 将用户文件夹指向自定义配置文件所在位置
   

3. 部署
   

4. 使用自定义主题
   

其他设置

Rime 使用心得

重点（必看！）

1. 很多人修改了方案不生效，或者新安装了 Rime，却发现无法使用，一个很重要但很容易被忽视的解决方案是：

   修改方案后，一定要点击部署！！！
   修改方案后，一定要点击部署！！！
   修改方案后，一定要点击部署！！！

   如何部署？点击这里

   • 【小狼毫】从开始菜单选择「重新部署」；或当开启托盘图标时，在托盘图标上右键选择「重新布署」；
   • 【鼠须管】在系统语言文字选单中选择「重新布署」；
   • 【中州韵】点击输入法状态栏（或IBus菜单）上的⟲ (Deploy) 按钮

2. 修改方案时，强烈建议使用 <输入方案名>.custom.yaml 的方式进行，除非这个方案是你自己原创！

3. 使用 <输入方案名>.custom.yaml 修改方案时，一定要写 patch ！

如何切换 Rime 输入方案

比如如果需要更换输入方案-小鹤双拼，那就需要创建 default.custom.yaml 文件，写入以下内容

# patch 一定要写
patch:
  schema_list:
    # 默认的明月拼音
    - schema: luna_pinyin_simp
    # 额外添加的小鹤双拼，前提是需要存在 double_pinyin_flypy.schema.yaml 文件，不然的话会导致无法输入字符
    - schema: double_pinyin_flypy

如何修改 Rime 输入方案的配置

1. 如果我们对默认的明月拼音方案的一些设置不满意，我们需要创建一个 luna_pinyin_simp.custom.yaml 文件。

   Q：为什么我要用 luna_pinyin_simp.custom.yaml，而不是 luna_pinyin_simp.schema.yaml，我听说 <输入方案名>.schema.yaml 才是输入方案的正确命名。
   A：<输入方案名>.schema.yaml 确实是输入方案的正确命名方式。
   A：我们使用 <输入方案名>.custom.yaml 是因为原始的 <输入方案名>.schema.yaml 方案（比如 luna_pinyin_simp.schema.yaml）是由他人所编写
   A：我们不使用 <输入方案名>.custom.yaml 而是直接修改 <输入方案名>.schema.yaml 文件进行自定义，如果作者对其进行了一些更新，我们会出现两种情况：

   1. 跟随原作者更新了 <输入方案名>.schema.yaml 文件，我们之前所做的自定义全部白费
   2. 不跟随更新，失去原作者新增或修复的功能

2. 在 luna_pinyin_simp.custom.yaml 中修改

   # 重点！custom.yaml 必须写 patch，且在第一行并只有一个
   patch:
     # 需要覆写的设置项
     xxxx: xxxx

一个高度定制化的 Rime 配置文件结构示例：

• opencc/*：OpenCC字形转换配置及字典文件，简繁转换，emoji 转换等
• custom_phrase.txt：自定义的词典
• default.custom.yaml：自定义的全局设置
• double_pinyin_flypy.custom.yaml：自定义的小鹤双拼输入方案设置
• double_pinyin_flypy.schema.yaml：从网上下载的小鹤双拼原始输入方案
• luna_pinyin_simp.custom.yaml：自定义的明月拼音输入方案设置
• pinyin_simp.dict.yaml：网上下载的默认词库文件
• squirrel.custom.yaml：自定义的 Squirrel 设置
• symbols.yaml：额外的关于表情符号的输入配置

如何删除自造词

1. 打错字后，立刻删掉是不会录入词库的。Rime 是在有新词输入时才把之前的词录入词库
2. 选中已造词，使用 Shift + Delete 即可删除
3. mbp 因为移除了 Delete 键，使用 Shift + Fn + Backspaces 键删除

如何同步 Rime 词库

同步原理

1. 点击同步按钮
2. 从 installation.yaml 中获取
   • installation_id
   • sync_dir
3. 在 sync_dir 文件夹下生成 installation_id 文件夹
4. Rime 会将 用户文件夹 下所有文件写入到步骤 3中文件夹
5. 根据 <词典名>.userdb/* 下的词典文件，生成一个词典快照文件 <词典名>.userdb.txt
6. 将快照文件内容与 sync 文件夹下其他文件夹的同名快照文件进行对比，更新当前步骤 5中词典文件
7. 将更新后的快照文件放入步骤 3中文件夹

所以重点是设置 installation.yaml 中的 installation_id 和 sync_dir

installation_id 默认为随机生成的 UUID
sync_dir 默认为 用户文件夹 下的 sync 文件夹

示例：

distribution_code_name: Squirrel
distribution_name: "鼠鬚管"
distribution_version: 0.14.0
install_time: "Tue Apr 28 22:33:50 2020"
rime_version: 1.5.3
# 上面几项由 Rime 维护

installation_id: "nuc8_mac"
sync_dir: "/Users/jiz4oh/OneDrive/RimeSync"

同步进阶

知道原理之后，我们可以通过云盘来同步不同设备的词库及设置

比如使用 OneDrive

1. 在 OneDrive 中设置 RimeSync 文件夹
2. 将设备 A 的 sync_dir 指向 OneDrive 下 RimeSync
3. 将设备 B 的 sync_dir 指向 OneDrive 下 RimeSync

这样就是实现了 A 和 B 的的词库同步

参考

注：本文由 Rime 鼠须管【小鹤双拼】输入方案撰写

1. RIME 官网

2. Rime 定製指南

3. Schema.yaml 詳解

最近在思考如何优化 web 应用的响应速度，常见的方式就是使用缓存，而最常接触的技术其实是服务端做共享缓存，例如 redis 缓存热点数据、CDN 缓存静态资源。在客户端做缓存这一块，知识面还比较窄，经过资料查询和思考，总结一些心得

缓存的目的

缓存是一种保存资源副本并在下次请求时直接使用该副本的技术

在不考虑成本的情况下，不使用缓存其实是体验最好方式，可以通过无限堆服务器来达到快速响应的目的，并且不会有一致性等问题。

所以缓存的目的很简单，就是缓解服务器压力，来达到在有限的成本情况下相对最优质的用户体验。

私有缓存和共享缓存

缓存的种类大致可分为：

• 共享缓存：可被多个用户重复使用，例如 redis 缓存热点数据，CDN 缓存静态资源
• 私有缓存：只能被单个用户使用，例如浏览器缓存

缓存控制

HTTP header: Cache-control

在 HTTP/1.1 中引入 Cache-control 头用来定义浏览器应该如何进行缓存决策

Cache-control 的值有：

• no-store：客户端不得存储任何关于客户端请求和服务端响应的内容。每次由客户端发起的请求都会下载完整的响应内容
• no-cache：客户端会缓存响应内容，但每次请求都会携带 验证字段 到服务器，验证缓存是否过期，未过期才使用本地已缓存内容
• public：响应内容可以被中间人如 CDN、网关等缓存
• private：响应内容只能被客户端缓存
• max-age：缓存过期的相对时间（秒），超过该时间后会再次发起请求
• must-revalidate：本地缓存未过期时使用本地缓存，本地缓存过期时必须携带 验证字段 到服务器，验证缓存是否过期

HTTP header: Expries

Expries 是 HTTP/1.0 中的内容，作用是指定缓存过期的绝对时间，例如 Expires: Wed, 21 Oct 2015 07:28:00 GMT

和 Cache-control: max-age 的区别：

• Expries 是绝对时间，Cache-control 是相对时间
• 在 HTTP/1.0 中 Expries 优先级大于 Cache-control，在 HTTP/1.1 及以后 Cache-control 优先级大于 Expries

缓存决策

强制缓存

由 Cache-control: max-age 或 Expires 指定的缓存，在时间过期之前，浏览器不会再次请求服务器

协商缓存

当缓存失效时，会发出 条件式请求，这时候和服务器的通信就称为协商缓存

协商缓存的优点：

• 省去了服务器生成 html 的时间
• 省去了响应体内容，传输更快

Last-Modified

请求响应流程：

1. 当浏览器第一次请求服务器时，服务器会返回 Last-Modified 头部表明当前资源的最后修改日期
2. 浏览器会将这个日期值缓存在本地
3. 当需要发出 条件请求 时，将日期值放在 If-Modified-Since 或 If-Unmodified-Since 头部中向服务器发出
4. 服务器判断日期，决定响应内容
5. 如果该资源新鲜，则返回 304，客户端使用该缓存渲染内容
6. 如果该资源被更改过，则返回 200，及全新内容

Etag

和 Last-Modified 的请求响应流程类似，不同的是服务器响应的是 ETag 头，浏览器发出请求时的头部为 If-Match 和 If-None-Match

• 强验证：HTTP 协议默认使用强验证，强验证要求文档的每一个字节都必须相同
  ETag: "618bbc92e2d35ea1945008b42799b0e7"
• 弱验证：ETag 头以 W/ 开头时为弱验证，此时只要求文档的内容含义是相同的。
  ETag: W/"618bbc92e2d35ea1945008b42799b0e7"

因为存在当资源时间更改，但是内容未改变等情况，Last-Modified 对资源的判断没有 ETag 准确，所以服务端处理的时候通常优先判断 ETag

决策图

刷新页面对 http 缓存的影响

三种刷新操作：

• 正常操作：地址栏输入 url，跳转链接，前进后退等
• 手动刷新：F5（mac 为 Cmd + R），点击刷新按钮，点击菜单刷新
• 强制刷新：Ctrl + F5（mac 为 Cmd + Shift + R）

不同刷新操作，不同的缓存策略：

• 正常操作：强制缓存有效，协商缓存有效
• 手动刷新：强制缓存失效，协商缓存有效
• 强制刷新：强制缓存失效，协商缓存失效

参考

HTTP 缓存

浅谈 HTTP 缓存

拷贝 EFI

1. 挂载 u 盘的 EFI 分区（在 Finder 中 带有三角符号的即是 u 盘的 EFI 分区）
2. 拷贝 EFI 分区下的 EFI 文件夹到桌面
3. 挂载磁盘的 EFI 分区（注：在 10.15.3 和 10.15.4 中 Finder 不会显示两个 EFI 磁盘，可以先卸载 u 盘 的 EFI 分区）
4. 将桌面的 EFI 文件夹拷入磁盘的 EFI 分区，替换其下的 EFI 文件夹

注入三码

1. 点击 Clover Configurator 左下角

   

2. 打开 EFI 分区 下的 EFI>CLOVER>config.list

3. 引导参数：
   

4. （可选）修改 UI 比例，解决开机过程中苹果 logo 从大变小
   

5. 生成序列号和 SMUUID，多点击几下避免随机
   

6. 生成设备的唯一标识号
   

7. 生成 ROM ID
   

8. 保存
   

9. 关闭 Clover Configurator，会提示不支持永久性的版本存储，点击 好

10. 重启 mac，此处可以拔出 U 盘了

易用性设置

必做设置

睡眠修复

1. 打开 Hackintool>电源
2. 修改睡眠值
   

可选设置

打开允许安装其他来源应用

终端执行：sudo spctl --master-disable

关闭读卡器显示

如果硬改了 NUC8，会在右上角出现一个卡片的标识
！！！waring：不要点击关闭卡会造成死机

解决办法是：

1. 10.15 Catalina 中系统分区默认为只读，故需执行：
   sudo mount -uw / && killall Finder
2. 关闭读卡器显示：
   fn=".`date +%s`" && sudo mv /System/Library/CoreServices/Menu\ Extras/ExpressCard.menu /System/Library/CoreServices/Menu\ Extras/ExpressCard.menu$fn && sudo touch /System/Library/CoreServices/Menu\ Extras/ExpressCard.menu

黑苹果下装 win10

制作 winpe

下载 winpe 和 纯净 win10 镜像，然后写入到 u 盘中

分区

！！！不要使用 BootCamp，黑苹果使用无效

1. 打开磁盘工具
2. 分一个 win10 系统盘的分区（格式随意，后期会重新格式化）出来，如果玩游戏多，可以多分一点
3. 分一个 500M 左右的分区作为 win10 efi 存放地址

重启到 winpe

1. 重启到 bios（一般是开机时按 F2 进入 bios）
2. 选择 winpe 的 uefi 启动
3. 打开 diskgenius，备份 efi 文件夹 A（此步为保留苹果和 clover 的启动文件），备份到外部磁盘，以防格盘
4. 选择安装 win10，选择安装文件夹为刚刚格式化的那个磁盘，引导文件夹选择 efi 文件夹 A 所在磁盘（必须先覆盖）
5. 安装完成后，重启到 win10，进行设置。。。
6. 重启到 winpe
7. 将 efi 文件夹 B 中的内容拷贝到 500M 分区中
8. 将之前备份的 efi 文件夹 A 中内容拷贝到当前 efi 文件夹 B 中，覆盖所有
9. 重启，会看见 clover。出现 win10 和 mac 双启动选项

问题汇总

1. 使用外置显卡坞为什么无法点亮？
   1. 进入 BIOS>Security 菜单
   2. 将 Thunderbolt Security Level 设置为 Legacy Mode
   3. 进入 BIOS>Boot 菜单
   4. Boot Configuration – Boot Devices – Thunderbolt Boot 开启

经常写 python 的开发一定苦恼过一个问题，那就是如何安装 python 环境。经常遇到如下问题：

1. 许多系统默认只自带 python2，导致现在很多使用 python3 的程序无法正常运行
2. python3 各版本间也不是完全兼容，某些第三库只支持特定的 python 版本

这些问题导致了我们经常会在各个版本间进行切换，甚至每个项目的 python 版本都不尽相同。所以我们需要一个环境管理器来帮助我们管理各个版本，这就用到了 pyenv。

而当我们项目过多之后，每个项目的依赖包就会有多个版本。这些依赖包的管理就需要用到 pipenv。

pyenv

安装

mac 使用 homebrew 安装 pyenv

brew install pyenv

设置环境变量

export PYENV_ROOT="$HOME/.pyenv"
export PATH="$PYENV_ROOT/bin:$PATH"
if command -v pyenv 1>/dev/null 2>&1;
then
  eval "$(pyenv init -)"
fi

• 如果使用的是 bash，则将上述代码粘贴到 ~/.bashrc 中
  重新加载环境变量，source ~/.bashrc
• 如果使用的是 zsh，则将上述代码粘贴到 ~/.zshrc 中
  重新加载环境变量，source ~/.zshrc

安装 python 3.6.6

pyenv install 3.6.6

默认使用 3.6.6

pyenv global 3.6.6

pyenv 常用命令

• 查看有哪些 Python 版本可以安装

  pyenv install --list

• 安装某个 Python 版本

  pyenv install 3.6.4

• 查看当前 Python 版本情况（* 表示系统当前的 Python 版本，system表示系统初始版本）

  pyenv versions

    system
  * 3.6.6 (set by /Users/jiz4oh/.pyenv/version)

• 切换 Python 默认版本

  # 切换全局默认版本
  pyenv global 3.6.6
  # 切换当前项目默认版本
  pyenv local 3.6.6
  # 切换 shell 使用的默认版本
  pyenv shell 3.6.6

• 卸载指定 Python 版本

  pyenv uninstall 3.6.6

pipenv

安装

mac 使用 homebrew 安装 pipenv

brew install pipenv

【2020.10.01】homebrew 安装版本为 2018.11.26_3，如果需要安装最新版本需要使用

pip3 install pipenv

参考

Pipenv – 超好用的 Python 包管理工具

lsblk：查看当前固件的分区信息

NAME         MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda            8:0    1 58.6G  0 disk
├─sda1         8:1    1  16M  0 part
├─sda2         8:2    1  300M  0 part /mnt/sda4

sda 2 中的浅蓝色和深蓝色区域为底层 Squash 格式，该格式只读，不支持修改，优势是可以在出错时轻松重置

overlay 就是在 upper layer 层进行读写的形式

overlay 的扩容并不是在 sda2 上进行操作，而是新建一个更大的分区 sda3，并将 Overlay 指向 sda3 ，这样的话，重置 sda2 后并不会损坏 sda3 中的配置

扩容步骤

创建新分区

使用 cfdisk 进行磁盘操作(使用 opkg install cfdisk 安装，如果安装失败请更新 opkg 源 opkg update)

1. cfdisk

   

2. 新建分区：切换到 free space ，切换到 new 回车，输入分区大小

   

   选择主分区或者扩展分区：选择 primary

   

3. 将更改写入分区表：光标移到新分区，选择 wirte，并输入 yes

   

4. 退出 cfdisk：选择 quit

   

格式化新分区

mkfs.ext4 /dev/sda3

挂载新分区

将 /dev/sda3 挂载到 /mnt/sda3 下：mount /dev/sda3 /mnt/sda3

ls /mnt/sda3 查看 /mnt/sda3 目录，如果有 lost+found 目录则表示挂载成功

拷贝 /overlay 下所有文件

ls /overlay 查看 /overlay 目录，如果有文件则拷贝到 /mnt/sda3 中

cp -r /overlay/* /mnt/sda3

检测是否拷贝成功

ls /mnt/sda3

在系统中挂载目录

重启路由器

参考

OPENWRT | ESXI 下 OpenWrt扩容Overlay,增加安装插件空间

一直对软路由这个东西念念不忘，想要入手折腾一下。最近因为家里需要一台服务器，我就把我的 n1 拿回了家里，转手就入了一个 j3455 的成品软路由，这边文章记录下在 pve 环境下折腾 openwrt 的心得，顺便学习下 pve（说不定能当个 IDC 呢

安装 PVE

1. 在官网中下载 ISO 镜像
2. 烧录到 U 盘中
3. 使用U盘启动
4. 安装，具体可参考【纯净安装】Proxmox-VE ISO原版 安装 全过程
5. 登录PVE后台，地址为 https://IP:8006，重点：https，使用 chrome 登录时因为证书不安全的原因会被拦截，选择信任

下载 OPENWRT 镜像

我使用的esir 的 x86 佛跳墙，下载是 gz 格式的压缩文件，需要解压为 img 格式的镜像文件

分配网卡

路由器最重要的就是将端口的网卡分配成 WAN 口和 LAN 口，这样才能形成一个网络拓扑结构。因为我是在 PVE 中安装虚拟机的方式使用 OPENWRT，所以需要先在 PVE 中将网卡映射到虚拟机中，路由器才能正确分配端口。

1. 安装 PVE 的过程中，我们已经将 eth0 口(也就是图上的 enp1s0) 虚拟成了 vmbr0

   

2. 因为我的软路由总共有4个网卡，所以我还需要虚拟3个网卡出来，和硬件口一一对应，比如将 en2s0 虚拟成 vmbr1，以此类推
   

   最终效果：

   

3. 应用配置

   

   如果遇到了这个错误，是因为没有 ifupdown2，需要在 shell 中执行 apt install -y ifupdown2

   

创建OPENWRT虚拟机

1. 点击右上角 创建虚拟机

2. 一般：输入名称并设置开机自启，点击下一步
   我使用的 openwrt，注意 VM ID，这是以后在 PVE 中操作虚拟机的关键

   

3. 操作系统：选择不使用任何介质，点击下一步
   稍后再上传镜像文件，因为需要对磁盘进行一些操作

   

4. 系统：全部默认，点击下一步

5. 硬盘：全部默认，点击下一步

6. CPU：选择分配给虚拟机的CPU，点击下一步
   按个人喜好分配 CPU 个数，我分配的 4 个，CPU 权重是在多个虚拟机中竞争 CPU 时，虚拟机的优先级，默认是 1024，可以增加 OPENWET 的权重保证网络通畅

   

7. 内存：按照个人喜好分配，如果只是单纯科学上网，1G足矣

8. 网络：模型选择 VirtIO
   桥接网卡随便选，后面会将全部网卡添加进来

   

9. 确认

配置虚拟机

1. 分离创建时选择的硬盘

   

2. 删除未使用的磁盘0和CD/DVD驱动器(ide2)

   

3. 上传之前下载的 OPENWRT img 文件

   

4. 拷贝镜像上传地址

   

5. 将 OPENWET 镜像导入磁盘
   在 shell 中执行 ：

   qm importdisk 100 /var/lib/vz/template/iso/openwrt-buddha-v2_2021_-x86-64-generic-squashfs-uefi.img local-lvm

   图中第一个绿框中的 100 为虚拟机的 VM ID，第二个绿框为刚刚上传的镜像地址

   

6. 设置磁盘

   

7. 调整引导顺序，将 sata0 磁盘启用并调整到第一位

   

8. 添加虚拟网卡，将之前虚拟出来的网卡都依次添加进去，还是使用 VirtIO 模型

   

9. 启动虚拟机

现在就可以使用 OPENWRT 了

参考

【纯净安装】Proxmox-VE ISO原版 安装 全过程

PVE安装Openwrt/LEDE软路由保姆级图文教程

当一个方法被调用时，要做的事情其实只有两件，1. 找到它。2. 调用它

接收者 receiver

接收者就是调用方法所在的对象。比如 'str'.to_sym 语句中，'str' 就是接收者。可以形象的理解为向这个接收者 'str' 发送了一条 to_sym 的消息

上面是显式指定接收者的例子，而在 Ruby 中是可以不指定接收者的，像这样：

class MyClass
  def my_method
    test
  end

  def test
    p "I'm Test"
  end
end

MyClass.new.my_method
# I'm Test

当一个字符串被调用时，Ruby 首先会在当前作用域查找是否有这个字符串对应的局部变量，如果没有时就会在 self 这个默认的接收者上调用方法

找到它：祖先链 ancestors

在面向对象的语言中，继承是一个很常见的概念，比如 Python 支持多继承，通过继承多个父类来复用代码，当方法被调用时，首先查找该对象是否有该方法，如果没有，则查找「方法解析顺序」（Method Resolution Order，或 MRO），而 MRO 通过 C3算法（python3）来计算，简单来说就是广度优先

而在 Ruby 中是不支持多继承的，转而使用 mixinx 的方式来实现代码的复用，mro 是通过搜索祖先链一直向上查找。当 Ruby 调用一个方法时，会首先查找对象是否有该方法，如果没有的话，则向上搜索整个祖先链，这就是 one step to the right, then up

class M1;end
class M2 < M1;end

# 查看祖先链
M2.ancestors  # [M2, M1, Object, Kernel, BasicObject]

include

include 是实现 mixinx 最常见的方式，当模块 A 被包含在类（或者模块）B 中时，这个 A 在 B 的祖先链的位置就在 B 之上，例：

module M1;end
module M2;end
module M3
 include M1
 include M2
end

M3.ancestors  # [M3, M2, M1]

prepend

prepend 方法类似于 include，不过这个方法会将模块插入祖先链的下方，例：

module M1;end
module M2;end
module M3
 prepend M1
 prepend M2
end

M3.ancestors  # [M2, M1, M3]

多重包含

当模块 C 包含模块 A、B，模块 B 包含模块 A 时，A 被重复导入，Ruby 会忽略已经被加入祖先链的重复模块导入

module A;end
module B
  include A
end
module C
  prepend A
  include B
end

B.ancestors   # [B, A]
C.ancestors   # [A, C, B]

更复杂的包含：

module M1;end
module M2;end
module M3;end
module M4
  include M1
  include M2
  prepend M3
end

module M5
  prepend M1
  include M2
  include M4
end

M4.ancestors  # [M3, M4, M2, M1]
M5.ancestors  # [M1, M5, M3, M4, M2]

调用它

刚刚我们已经通过祖先链找到了方法，接下来就要执行这个方法。假如有以下方法：

def my_method
  temp = 1
  my_other_method(temp)
end

当执行 my_method 方法时，方法内部需要调用 my_other_method，而该由哪个对象来调用这个方法？

self 关键字

Ruby 中的每一行代码都会在一个对象中被执行–这个对象就是所谓的当前对象。

当前对象可以用 self 关键字来指代，而所有没有明确指明接收者的方法都会在 self 上调用。

class MyClass
  def testing_self
    @var = 10
    my_method()
    self
  end

  def my_method
    @var += 1
  end
end

obj = MyClass.new
obj.testing_self  # <MyClass:0x00007faea4131b90 @var=11>

private 是怎么实现的

private 方法遵从一个简单的规则：

不能明确指定接收者来调用私有方法

class C
  def public_method
    self.private_method
  end

  private def private_method
    1
  end
end

C.new.public_method  # NoMethodError (private method `private_method' called for #<C:0x00007fd0c40feb90>)

总结：

1. 如果需要调用其他对象的方法，必须显式指定接收者
2. 私有方法不能明确指定接收者来调用

所以私有方法不能被其他对象调用，不能被自身显式 self 调用，只能隐式 self 调用

参考

Ruby元编程

Devise 是 ruby 世界中最常见的 gem 之一，是用于在 web 请求中做身份验证的，他的设计非常精妙，今天我们来尝试看看 devise 是如何设计的。

如何使用 Devise

devise 的使用重点是为 rails 的 MVC 三层中各引入 devise 相关的 magic 方法，比如我们今天以 User 模型为例

1. 为 controller 层和 view 层引入 devise，需要在 config/routes.rb 中引入

   devise_for :users

def devise_for(*resources)
  ...
  ...

  resources.each do |resource|
    mapping = Devise.add_mapping(resource, options)

    begin
      raise_no_devise_method_error!(mapping.class_name) unless mapping.to.respond_to?(:devise)
    rescue NameError => e
      raise unless mapping.class_name == resource.to_s.classify
      warn "[WARNING] You provided devise_for #{resource.inspect} but there is " \
        "no model #{mapping.class_name} defined in your application"
      next
    rescue NoMethodError => e
      raise unless e.message.include?("undefined method `devise'")
      raise_no_devise_method_error!(mapping.class_name)
    end

    ...
    ...
  end
end

# Small method that adds a mapping to Devise.
def self.add_mapping(resource, options)
  mapping = Devise::Mapping.new(resource, options)
  @@mappings[mapping.name] = mapping
  @@default_scope ||= mapping.name
  @@helpers.each { |h| h.define_helpers(mapping) }
  mapping
end

class ApplicationController < ActionController::Base
  before_action :authenticate_user!
end

# 为了方便，我将源码中元编程生成的代码换成了普通的 ruby 代码
def authenticate_user!(opts={})
  opts[:scope] = :user
  warden.authenticate!(opts) if !devise_controller? || opts.delete(:force)
end

def warden
  request.env['warden'] or raise MissingWarden
end

class MissingWarden < StandardError
  def initialize
    super "Devise could not find the `Warden::Proxy` instance on your request environment.\n" + \
      "Make sure that your application is loading Devise and Warden as expected and that " + \
      "the `Warden::Manager` middleware is present in your middleware stack.\n" + \
      "If you are seeing this on one of your tests, ensure that your tests are either " + \
      "executing the Rails middleware stack or that your tests are using the `Devise::Test::ControllerHelpers` " + \
      "module to inject the `request.env['warden']` object for you."
  end
end

$ rails middleware
use Webpacker::DevServerProxy
use Raven::Rack
use Rack::Cors
use ActionDispatch::HostAuthorization
use Rack::Sendfile
use ActionDispatch::Static
use ActionDispatch::Executor
use ActiveSupport::Cache::Strategy::LocalCache::Middleware
use Rack::Runtime
use Rack::MethodOverride
use ActionDispatch::RequestId
use RequestStore::Middleware
use ActionDispatch::RemoteIp
use Sprockets::Rails::QuietAssets
use Rails::Rack::Logger
use ActionDispatch::ShowExceptions
use WebConsole::Middleware
use ActionDispatch::DebugExceptions
use ActionDispatch::ActionableExceptions
use ActionDispatch::Reloader
use ActionDispatch::Callbacks
use ActiveRecord::Migration::CheckPending
use ActionDispatch::Cookies
use ActionDispatch::Session::CookieStore
use ActionDispatch::Flash
use ActionDispatch::ContentSecurityPolicy::Middleware
use Rack::Head
use Rack::ConditionalGet
use Rack::ETag
use Rack::TempfileReaper
use Warden::Manager
use ExceptionNotification::Rack
use Rack::Attack
run ApplictionName::Application.routes

# config.ru
use MiddleWare1
use MiddleWare2
run RackApp

# equals to
MiddleWare1.new(MiddleWare2.new(RackApp)))

module Warden
  class Manager
    extend Warden::Hooks

    attr_accessor :config

    def initialize(app, options={})
      default_strategies = options.delete(:default_strategies)

      @app, @config = app, Warden::Config.new(options)
      @config.default_strategies(*default_strategies) if default_strategies
      yield @config if block_given?
    end

    def call(env) # :nodoc:
      return @app.call(env) if env['warden'] && env['warden'].manager != self

      env['warden'] = Proxy.new(env, self)
      result = catch(:warden) do
        env['warden'].on_request
        @app.call(env)
      end

      result ||= {}
      case result
      when Array
        handle_chain_result(result.first, result, env)
      when Hash
        process_unauthenticated(env, result)
      when Rack::Response
        handle_chain_result(result.status, result, env)
      end
    end
end

def process_unauthenticated(env, options={})
  options[:action] ||= begin
    opts = config[:scope_defaults][config.default_scope] || {}
    opts[:action] || 'unauthenticated'
  end

  proxy  = env['warden']
  result = options[:result] || proxy.result

  case result
  when :redirect
    body = proxy.message || "You are being redirected to #{proxy.headers['Location']}"
    [proxy.status, proxy.headers, [body]]
  when :custom
    proxy.custom_response
  else
    options[:message] ||= proxy.message
    call_failure_app(env, options)
  end
end

def call_failure_app(env, options = {})
  if config.failure_app
    options.merge!(:attempted_path => ::Rack::Request.new(env).fullpath)
    env["PATH_INFO"] = "/#{options[:action]}"
    env["warden.options"] = options

    _run_callbacks(:before_failure, env, options)
    config.failure_app.call(env).to_a
  else
    raise "No Failure App provided"
  end
end

def authenticate!(*args)
  user, opts = _perform_authentication(*args)
  throw(:warden, opts) unless user
  user
end

def _perform_authentication(*args)
  scope, opts = _retrieve_scope_and_opts(args)
  user = nil

  return user, opts if user = user(opts.merge(:scope => scope))
  _run_strategies_for(scope, args)

  if winning_strategy && winning_strategy.successful?
    opts[:store] = opts.fetch(:store, winning_strategy.store?)
    set_user(winning_strategy.user, opts.merge!(:event => :authentication))
  end

  [@users[scope], opts]
end

def devise(*modules)
  options = modules.extract_options!.dup

  selected_modules = modules.map(&:to_sym).uniq.sort_by do |s|
    Devise::ALL.index(s) || -1  # follow Devise::ALL order
  end

  devise_modules_hook! do
    include Devise::Models::Authenticatable

    selected_modules.each do |m|
      mod = Devise::Models.const_get(m.to_s.classify)

      if mod.const_defined?("ClassMethods")
        class_mod = mod.const_get("ClassMethods")
        extend class_mod

        if class_mod.respond_to?(:available_configs)
          available_configs = class_mod.available_configs
          available_configs.each do |config|
            next unless options.key?(config)
            send(:"#{config}=", options.delete(config))
          end
        end
      end

      include mod
    end

    self.devise_modules |= selected_modules
    options.each { |key, value| send(:"#{key}=", value) }
  end
end

module Devise
  class Mapping
    def modules
      @modules ||= to.respond_to?(:devise_modules) ? to.devise_modules : []
    end

    def strategies
      @strategies ||= STRATEGIES.values_at(*self.modules).compact.uniq.reverse
    end
  end
end

def self.configure_warden! #:nodoc:
  @@warden_configured ||= begin
    warden_config.failure_app   = Devise::Delegator.new
    warden_config.default_scope = Devise.default_scope
    warden_config.intercept_401 = false

    Devise.mappings.each_value do |mapping|
      warden_config.scope_defaults mapping.name, strategies: mapping.strategies

      warden_config.serialize_into_session(mapping.name) do |record|
        mapping.to.serialize_into_session(record)
      end

      warden_config.serialize_from_session(mapping.name) do |args|
        mapping.to.serialize_from_session(*args)
      end
    end

    @@warden_config_blocks.map { |block| block.call Devise.warden_config }
    true
  end
end

def default_strategies(*strategies)
  opts  = Hash === strategies.last ? strategies.pop : {}
  hash  = self[:default_strategies]
  scope = opts[:scope] || :_all

  hash[scope] = strategies.flatten unless strategies.empty?
  hash[scope] || hash[:_all] || []
end

def scope_defaults(scope, opts = {})
  if strategies = opts.delete(:strategies)
    default_strategies(strategies, :scope => scope)
  end
  ...
end

def authenticate!
  resource  = password.present? && mapping.to.find_for_database_authentication(authentication_hash)
  hashed = false

  if validate(resource){ hashed = true; resource.valid_password?(password) }
    remember_me(resource)
    resource.after_database_authentication
    success!(resource)
  end

  mapping.to.new.password = password if !hashed && Devise.paranoid
  unless resource
    Devise.paranoid ? fail(:invalid) : fail(:not_found_in_database)
  end
end

def authenticate!
  resource = mapping.to.serialize_from_cookie(*remember_cookie)

  unless resource
    cookies.delete(remember_key)
    return pass
  end

  if validate(resource)
    remember_me(resource) if extend_remember_me?(resource)
    resource.after_remembered
    success!(resource)
  end
end

常在河边走，哪有不湿鞋 –鲁迅

作为多年使用 JetBrains 盗版软件的不法用户，昨日终于被逮到了，经历各种再破解尝试，均告失败。
只好转战最近广受好评的 vscode，准备接下来试试能不能作为主力开发工具。
本篇记录如何在 vscode 配置开发 ruby 环境

安装 vscode

vscode 的安装就不赘述了，在官网直接下载，傻瓜式安装就 ok 了。

配置 vscode

安装配置扩展 ruby

1. 这个扩展名称就叫 ruby（作者吕鹏，vscode官方开发人员），在 vscode 应用商店中直接搜索安装就好

2. 在 vscode 配置文件 settings.json 中添加如下

   "ruby.useBundler": true,
   "ruby.lint": {
     "rubocop": {
       "useBundler": true
     },
   },
   "ruby.format": "rubocop",

安装配置扩展 Ruby Solargraph

1. 在 vscode 应用商店搜索安装

2. 在 settings.json 中添加

   "solargraph.useBundler": true,
   "solargraph.references": true,
   "solargraph.autoformat": true,
   "solargraph.formatting": true,

配置运行环境

在项目目录下新建 .vscode/launch.js

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Rails server",
      "type": "Ruby",
      "request": "launch",
      "program": "${workspaceRoot}/bin/rails",
      "args": [
        "server"
      ],
      "env": {
        "PATH": "xxxx",
        "GEM_HOME": "xxx",
        "GEM_PATH": "xxx",
        "RUBY_VERSION": "xxx"
      }
    }
  ]
}

env 详细内容请在 shell 使用下列命令输出

printf "\n\"env\": {\n  \"PATH\": \"$PATH\",\n  \"GEM_HOME\": \"$GEM_HOME\",\n  \"GEM_PATH\": \"$GEM_PATH\",\n  \"RUBY_VERSION\": \"$RUBY_VERSION\"\n}\n\n"