mizuhashi (mizuhashi)

一個用 DIDComm 實現服務器間通信的 Rails demo

mizuhashi — Wed, 04 Mar 2026 07:14:39 +0800

DIDComm是一個基於 W3C DID（去中心化 ID）的通信協議。如果一個服務器想和另一個實現了 DIDComm 的服務器通信，它會需要在/.well-known/did.json 提供一個 DID 文檔，文檔裏包含了公鑰以及 DIDComm 的 service endpoint。我的 demo 服務器的 DID 文檔長這樣：https://dc.mbkr.ca/.well-known/did.json 。

擁有了這個文檔之後，did:web:dc.mbkr.ca這個 DID 就會對應我的服務器，你只需要這個 id 就可以給我發信息，發信方會根據這個 id 解析到 DID 文檔，獲取公鑰構建信息，並推到 service endpoint 上。

我也做了一個公開的 demo 服務器， https://dc-public.mbkr.ca/ ，你可以用public做密碼登錄。

Demo 的 repo: https://github.com/onyxblade/didcomm-rails-demo

實現上，我本來是讓 AI 生成了一個 Ruby 版本的 DIDComm 實現，不過密碼學的內容很多，我最後還是決定直接用didcomm-rust這個標準的參考實現。這個 Rust 的實現可以輸出 wasm，但 wasmtime-rb 好像還沒成熟到能直接用，所以最終我做了一個 HTTP 服務器didcomm-http，來把 wasm 接口包裝成 HTTP API。

Happy Hacking!

WhereableScope: 把 scope 用作 where 參數

mizuhashi — Thu, 29 Jan 2026 13:56:51 +0800

https://github.com/onyxblade/whereable_scope

例子：

class Order < ActiveRecord::Base
  has_one :order_address
  has_one :address, through: :order_address

  scope :by_address, ->(address) { joins(:order_address).where(order_addresses: { address: address }) }

  # 把by_address scope註冊為可用的where參數
  whereable_scope :by_address, as: :address
end

# 現在你可以：
Order.where(address: address)

僅供娛樂

Ruby 的 TUI 庫 Ratatui-Ruby

mizuhashi — Thu, 22 Jan 2026 03:57:41 +0800

reddit 上看到的：https://www.ratatui-ruby.dev/

一點關於 AI 編程的思考

mizuhashi — Wed, 23 Jul 2025 05:29:24 +0800

程序員的工作，本質上是在做語言翻譯，將描述需求的人類語言翻譯到機器語言。其中，需求語言是抽象的，就像用戶說「我要一輛車」，是一種概括性的描述，但要實際把車造出來，就要落實到非常具象的語言，因為無論是計算機還是現實物理，都有非常具體的規則，錯一點就會不能用。這種抽象程度的差異可以理解為信息量的差異，給定一個車的概念，它可以有成千上萬種樣子，但到生產出來的具體型號，就只剩下了一種，其他所有樣子都被排除了，這也是信息論裏提出的「信息量即是排除可能性的多寡」。

於是程序員的工作本質上是對信息的補足，這種補足是通過不斷疊加約束實現的，每個新增加的細節都是約束，能砍掉一部分可能性，直到最後可能性剩下一種。具體地說，給定一個需求，程序員會想到一些潛在的方案，每個方案會有新加入的約束，提出方案本身就是補充了原本不存在的信息。那麼如何從潛在方案中選擇呢？程序員需要在需求中找到一些能指引選擇的原始約束，例如把方案介紹給產品詢問意見，或者根據自身的經驗預測一下未來的需要，這實際上就是擴充了上下文。

AI 的代碼生成工作在上述翻譯鏈的後半段，它會從程序員那取得中間階段的語言，然後生成具體的代碼。如果 AI 更聰明，那麼程序員應當可以提供更抽象的語言，讓 AI 自己補足信息，而如果 AI 更笨，程序員就需要提供更多信息，才能保證最終代碼的可用。於是，我們有了一個度量 AI 聰明程度的方法，也有了一種適應 AI 的策略，就是如果 AI 不夠聰明，就提供更多細節直到它能寫出來。

Camille：让前端和 Rails 进行类型安全的通信

mizuhashi — Mon, 20 Mar 2023 08:47:51 +0800

之前在 https://ruby-china.org/topics/42643 这个帖子提到过在 Rails 端生成带类型的 API 调用函数，来让前后端通信实现类型安全，现在终于做成成品 gem 了。

Github Repo: https://github.com/onyxblade/camille

用 Rails 做 API server 的时候，我们返回的 json 是没有经过类型检查的，这样即使前端用上了 typescript，我们也不能保证 Rails 返回的 JSON 是预期的结构和类型。于是我做了这个 gem 来在 Rails 端定义 API 接口的类型，并生成 ts 的调用函数，这样调用的参数和返回就都是类型安全的了。

简而言之它的作用就是可以给 controller action 的 params 和 response 加上类型，例如对一个books#create action，可以通过下面的代码加上类型：

using Camille::Syntax

class Camille::Schemas::Books < Camille::Schema
  include Camille::Types

  post :create do
    params(
      book: {
        name: String,
        author: String,
        retail_price: Decimal
      }
    )
    response(Boolean)
  end
end

然后可以生成前端的调用函数：

// This file is automatically generated.
import request from './request'

export type DateTime = string
export type Decimal = number

export default {
  books: {
    create(params: {book: {name: string, author: string, retailPrice: Decimal}}): Promise<boolean>{ return request('post', '/books/create', params) },
  },
}

这样前端可以通过下面的方式调用：

const bool = await endpoints.books.create({
  book: {
    name: 'Metaprogramming Ruby',
    author: 'Paolo Perrotta',
    retailPrice: 27.95
  }
})

这个调用的参数和返回值都是类型安全的，如果前端出错了 TS 会给出提示，后端出错则会被运行时检查查出来。同时请求的 path 也是不需要程序员管理的，程序员只要调用函数就好，Camille 会确保请求被正确的 action 处理。

https://github.com/onyxblade/camille-tutorial 这里有一个 step by step 的 tutorial，感兴趣的也可以看看。

Camille 目前做到了支持 typescript 的除了 enum 和 utility types 的绝大部分类型语法（utility types 支持 omit 和 pick），基本是一模一样的，在这个过程中用到了至今还没见有人用过的 refinement，算是比较好玩的一点。具体的语法列表可以参见 https://github.com/onyxblade/camille#available-syntax-for-types 。

欢迎试用和反馈，如果有需要的 feature requests 也可以加上。

各位在写测试的时候会常用 mock 吗？

mizuhashi — Fri, 21 Oct 2022 10:23:45 +0800

有位同事特别喜欢用 mock，测试一个 service 的时候会把所有外部依赖都用 mock 写，以此隔离测试代码。他的理由有，service A 依赖 service B，在 A 的单测中如果直接调用 B 来准备测试数据，那么 B 在后面的时候可能会不断增长，然后引入很多和 A 无关的东西，也可能 break A 的测试。而如果用 mock 的话，A 的测试是不需要改的，写测试的时候关注点也只会在 A 内部。但是我认为如果这么干，会需要一些额外的代码来测 A 对 B 的依赖，不然不能保证 B 的运行结果和最初的 mock 数据是一样的，这实际上增加了测试的代码量，而且测试本来应该是为了发现问题，而不是作为“不会有问题”的代码，如果用维护业务代码的方式维护测试，似乎就失去了测试的意义。

我想了一种折中方案，就是通过实际调用 service 来准备数据，然后把这些数据 dump 一份，保存来用作 mock，这样 service 改变这个 dump 也不会变，可以很好地满足他想要隔离测试的想法。然后可以监视一个 service 生成的新的 dump 和以往的 dump 是不是有不同，如果有不同，就更新一下 dump 的版本看看单元测试还能不能过。这样如果 dump 更新得勤，就能实现我想要的发现问题。这样好像是不错的，可以实际观测到 service 改动所产生的效应，不过可能需要造一些轮子。

大家觉得在 Rails 端生成带类型的前端 API 调用代码有搞头吗？

mizuhashi — Fri, 09 Sep 2022 23:14:49 +0800

这样可以确保后端返回的 json 和前端 ts 里的 json 是相同类型的，前端在调用 api 的时候也可以确保提供了后端要求的 params。

例如这样的 ruby 代码：

endpoint :recipe_data do
  params do
    number :id
  end

  response do
    recipe :recipe
  end
end

会生成前端的 ts 代码：

interface recipe {id: number, title: string, subtitle: string}
function api_recipe_data(params: {id: number}) : Promise<{recipe: recipe}> {
  return useApi('api/recipe_data', params)
}

export default { api_recipe_data}

其中recipe是一个自定义的类型，在另一个地方定义了它应该有的 interface。这个目前的实现并不复杂，但是如果要做成通用的 rails 插件估计很麻烦，不知道值不值得

docker 部署可以做成类似 mina 和 cap 的工具吗？

mizuhashi — Thu, 25 Nov 2021 16:09:45 +0800

用 docker 之后的部署流程都是 build push，然后 ssh 到服务器上 pull，但是我觉得这部分应该是可以用类似 mina 的东西解决的。这部分大家都是自己写脚本吗，还是有惯常使用的插件之类的？

Imba - 一个转译到 js 的新编程语言

mizuhashi — Wed, 27 Oct 2021 09:57:01 +0800

https://imba.io/

缩进语法，element 是第一公民，还怀念 coffeescript 的可以试试

======更新======

https://imba.io/tags/declarative-rendering 这个描述了 imba 的更新逻辑，它采用的是和 mithril.js 一样的，当每次事件结束的时候全局进行更新，并没有采用任何响应式设计。如果要优化这个更新逻辑，需要先 silence 掉事件，然后手动更新需要更新的组件。

编程语言谜语

mizuhashi — Wed, 02 Sep 2020 16:19:30 +0800

打算写的小说里要用到一些咒语，就根据历史上的编程语言尝试写了些，其中每行代表一个或多个编程语言。

过程转写的方程式
自解释的树状结构
顺流而下的字母表
模拟世界的活跃体
有限空间的问答机
可变形的红色宝石
D 大调的协和半音
无限延伸的类之类
违规借用的拒绝者

猜对没奖 lol

谜底更新在 7 楼

PostGraphile：将 Postgres 数据库变成全功能 GraphQL 后端

mizuhashi — Wed, 26 Aug 2020 18:08:55 +0800

https://www.graphile.org/

这个工具可以直接把一个 postgres 数据库生成为一个 graphql 后端，内置了对每个表格的 crud query 及 mutation。

为什么说是全功能的呢？因为仅仅通过 graphile 和 pg 可以做到传统后端需要的任何事，而且所有需要写的代码和配置都在 postgres 里，迁移的时候直接导出 postgres 数据库，就能备份整个后端。

除了生成的 crud，用户可以用 pl/sql 写业务逻辑的函数，一个有副作用（cud）的函数会直接挂载为 graphql 的 mutation，无副作用的则会挂载为 query。

graphile 对数据库的更新鉴权是使用 pg 内置的 role 和 row level security 实现的。一般应用需要两个 role：登陆前的 anonymous 和登陆后的 user。我们可以通过 grant 来对不同 role 配置他们能对表进行的操作，而 row level security 则允许我们配置一个 session 对行的权限，在 cud 行的时候，可以执行一些 check，例如检查当前用户 id 是不是和要修改的数据一样。

和 hasura 对比的好处：

graphile 以 postgres 为中心，没有自己的 metadata。hasura 把关联的配置保存为一份自己的配置，这样在迁移的时候除了导出数据库，还需要导出 hasura 的配置。而 graphile 的关联信息是完全通过 pg 内的外键关联推导出来的。
hasura 实现登陆鉴权功能的时候需要一个外部服务器。graphile 不需要一个额外的服务器，凭借自身就可以实现登陆注册，签署 jwt。
graphile 使用 pg 内置的 row level security 来处理权限，而 hasura 是用一套自己的鉴权机制来处理的。

期待使用 graphile 做出的纯 pg 后端的应用。

bootstrap-sass 3.2.0.3 版本被发现藏有远程执行代码后门

mizuhashi — Fri, 05 Apr 2019 01:07:07 +0800

https://snyk.io/blog/malicious-remote-code-execution-backdoor-discovered-in-the-popular-bootstrap-sass-ruby-gem/

package-lock.json that doesn't lock

mizuhashi — Thu, 09 Nov 2017 10:47:11 +0800

转自 https://twitter.com/javan/status/905194268297441285

根据图中的 stackoverflow 回答，npm 5.1.0 之后，package-lock.json 只锁定那些无前缀的声明，如1.2.0，而不包括^1.2.0。npm 的这个操作依旧是让人看不懂，有锁定需求的还是继续 yarn 吧....

======update======

发现这个"issue"在 5.4.2 被修复，现在能锁了....

行为如 Issue#17979最后一个回复。

pretty_ancestors: 打印包含层级的 ancestors 信息

mizuhashi — Fri, 28 Apr 2017 12:01:48 +0800

ruby 使用 mixin 的时候是直接 copy 到原型链的，ancestors 返回的是一维数组，于是尝试了一下用 ancestors 还原出 include 和 prepend 的结构，调试的时候可以用到。

安装：

gem install pretty_ancestors

例子：

module M1
  include (Module.new{})
end

module M2
  include M1
end

module M3
end

module M4
  prepend M3
end

module M5
end

class C
  include M4
  include M2
  prepend M5
end

pp C.pretty_ancestors
# =>
# [[[M5], C, [[M2, [[M1, [#<Module:0x00000000f546f0>]]]], [[M3], M4]]],
#  [Object,
#   [PP::ObjectMixin, Kernel]],
#  BasicObject]

pp C.pretty_ancestors(:raw)
# =>
# [[[[[], M5, []]],
#   C,
#   [[[], M2, [[[], M1, [[[], #<Module:0x00000000f546f0>, []]]]]],
#    [[[[], M3, []]], M4, []]]],
#  [[], Object, [[[], PP::ObjectMixin, []], [[], Kernel, []]]],
#  [[], BasicObject, []]]

在 raw 数据中每个模块 M 都被表示为[[*prepended], M, [*included]]，普通输出则是去掉了所有[]的简化。对于 Class，pretty_ancestors 的第一维是继承链上的类。

C.pretty_ancestors.flatten 总是等于 C.ancestors，所以可以直接按顺序确定优先级。

github: https://github.com/CicholGricenchos/pretty_ancestors

另求 pretty_print 调教经验。。

ancestry 和 closure_tree 的批量读对比

mizuhashi — Mon, 17 Apr 2017 20:53:39 +0800

update：這篇文章的內容實際上完全是錯的…

用 Ruby 做编译原理大作业

mizuhashi — Sun, 12 Mar 2017 22:31:23 +0800

https://github.com/CicholGricenchos/tiny-c

做了一个微型 c 编译器，大概四百来行，可以编译一些简单的 c 代码（参见测试用例）。

语法分析自己写了一套 DSL，用深度优先搜索找一个可行的解，大概算是 LL(0)？这样语法定义可以写的比较简洁，但是坏处是不能给出“unexpected token xxx”这样细致的提示，因为在搜索途中不知道哪个规则才是正确的。

有了语法树（sexp）之后，就可以直接塞到 interpreter 递归执行了，也可以塞到 compiler 生成汇编，同样是在一次递归里完成。

compiler 会将每个语法树节点直译成汇编代码，途中想了好久应该怎么分配寄存器，但是还是搞不定，所以汇编中有不少多余的出入栈代码，来保证每个操作都是相互隔离的，当然代码也变慢了很多。不过能正确运行就很开心了。。

Ruby as awk

mizuhashi — Fri, 20 Jan 2017 12:02:11 +0800

在 shell 配置添加一个 alias：

alias rawk 'ruby -r ~/rawk.rb -ne'

在~/rawk.rb 添加要用到的处理方法：

def pid line
  line.split(/\s+/)[1]
end

使用它：

(´_ゝ`)旦 ~ ps aux | grep rails | rawk 'puts pid $_'
7940
11478

其中-e 是执行脚本，-n 是对每行输入执行脚本，-r 是执行前引入。

参考 http://nithinbekal.com/posts/ruby-sed-awk/

Rubinius 正在成为 Ruby 的方言

mizuhashi — Wed, 11 Jan 2017 20:51:13 +0800

https://medium.com/@rubinius/rubinius-takes-the-fun-out-of-ruby-21db64ce87a6

Rubinius 不再自称 Ruby 已经有一段时间了，不过官网上也看不太出他们到底想干什么，刚刚去看了他们的博客，才知道他们打算把 Rubinius 做成 Ruby 的扩展。

例如这篇博文提到，为 Ruby 添加了函数，类型和模式匹配语法：


# Note the block syntax to get around not being
# able to make 'data' a keyword.
data str do
  # ...
end

data int do
  # ...
end

data color do
  # ...
end

# The types above would be defined at the system level
# and available for import as desired.

data MyModel do
  field :name, str
  field :age, int
  field :color, color

  # Return type is specified by annotations.
  type bool
  fun compare_age(a: int, b: int)
    a <=> b
  end
end

文中提到 Object Oriented 面向组件的交互，而 Functional 面向数据操作，OO 和 FP 是对立的，但是可以各取所需。也就是在实际的工程中，应该依据不同的需求选用不同的范式，而不是分成两个派系相互对立。

而作者本人花了八年尝试说服 Ruby 团队接受这些新的设计，依旧没有结果，只好自己来做了这个"additions to Ruby"。

Rubinius 还设计了一个 defm 关键字，可以用来简化 case when：

class Array
  defm [](index)
    # return element at index or nil
  end

  defm [](index, num)
    # return num elements starting at index
  end

  defm [](index: Integer())
    # convert index to an Integer if it's not already
  end

  defm [](range: Range())
    # convert range to a Range if it's not already
  end
end

这个大概就是 [] 的实际定义，index: Integer() 意味着匹配可以被转换为 Integer 的对象。

其实做方言还是不错的，只能希望未来和 Ruby 本身不会有太多冲突，因为 Ruby 目前没有靠谱的 LLVM 前端，如果 Rubinius 不做了，wasm 平台可能就看不到 Ruby 的身影了。

我个人认为模式匹配不是真的那么重要，只是些锦上添花的东西，其实用 dsl 写也没差....Ruby 倒是挺需要一个 import/export，来解决常量作用域的问题..

AR 有办法将一个查询虚拟成 has_one 关联吗？(答案是可以)

mizuhashi — Mon, 19 Dec 2016 11:54:44 +0800

场景：

原来 model 里有 product has_one review_summary，review_summary 是一个 reviews 的统计数据，目前由定时任务以及回调更新。
现在这个 summary 的逻辑简化了，可以通过一个简单的查询查出来，所以想将原来的 has_one 关联替换成一个查询，这样可以沿用之前 includes 的代码，逻辑上也是一致的。

我知道视图可以做这个，但是希望可以在 ruby 的层面上做这个事情，不知可有好的方法？

Ruby 的 pipe

mizuhashi — Thu, 08 Dec 2016 17:33:11 +0800

（误

class Object
  class Proxy < BasicObject
    def method_missing name, *args, &block
      @target = @target.send(name, *args, &block)
    end

    def initialize target
      @target = target
    end
  end

  def pipe &block
    Proxy.new(self).instance_eval &block
  end
end

p [1,2,3].map{|x| %w{a b c d}[x] }.join.capitalize # => "Bcd"

[1,2,3].pipe do
  map{|x| %w{a b c d}[x] }
  join
  capitalize
  p self
end # => "Bcd"