2013年9月18日水曜日
引っ越しました
2011年12月7日水曜日
Play Framework 2.0 と JSON ライブラリ Jerksonについて調べてみました。
の7日目です。
勢いで参加してみたものの、ネタが見つからず困っていたところ、@mumoshu さんのつぶやきが目にとまりました。
-- this quote was brought to you by quoteurl
mumoshu この2日間のPlay 2.0は、Scala向けのJSON APIが変更されたり、Actionの合成方法がドキュメントにそった形になった。JSONの方は、使うライブラリがsjsonからJerksonへ変更。Jerksonをベースに、sjsonのようなAPIを実装している。 04 Dec 2011 from Twitter for Mac
Jerksonというライブラリは全く知りませんでした。
調度良いのでこのJerksonについて調べたことを書こうと思います。
(Play20のplay.api.jsonは、現在絶賛開発中といった感じなので、これからしばらく不安定な様子です。
おそらくここに書くこともすぐに古くなると思いますのでご了承ください。)
Jerksonって?
Jerksonは、Java JSON-processorであるところのJacksonの、Scala wrapperです。
これまで候補であったsjsonについては@eed3si9n さんの翻訳記事、
sjson: Scala の型クラスによる JSON シリアライゼーション に詳しく書かれています。sjsonは、implicit parameterによる型クラスエミュレートを使った便利なライブラリです。sjsonでは、型クラスを使うことでシリアライズ、デシリアライズプロトコルのカスタマイズ手段を提供しています。
sjsonからJackson/Jerksonに移行した理由はわかりませんが、ScalaとJavaを両方サポートするPlay!ではJavaベースのJacksonとそのScala wrapperというのが都合が良かったのかもしれません。
play.api.jsonでは、このJerksonに、sjsonライクなシリアライズ/デシリアライズプロトコルをかぶせた形になっています。
apiとしては、まずJsValue型とStringの相互変換をする2つの関数が用意されています。
def parseJson(input: String): JsValue = JerksonJson.parse[JsValue](input)
def stringify(json: JsValue): String = JerksonJson.generate(json)
parseJsonは、StringからJsValueへ、stringfyはその逆で、JsValueをStringにします。
これらの中身はJerksonにそのままお任せで、特にカスタマイズも想定されていますん。
JsValue という型が中間表現になっていて、任意のScalaオブジェクトをJsValueにしてからStringにしたり、
JSON文字列をパースしてまずはJsValueにしてから、任意のScalaオブジェクトに変換することになります。
ちなみにJsValueという型は次のような構成になっています。
sealed trait JsValue {...}
case object JsNull extends JsValue {...}
case class JsUndefined(error: String) extends JsValue {...}
case class JsBoolean(override val value: Boolean) extends JsValue
case class JsNumber(override val value: BigDecimal) extends JsValue
case class JsString(override val value: String) extends JsValue
case class JsArray(override val value: List[JsValue]) extends JsValue {...}
case class JsObject(override val value: Map[String, JsValue]) extends JsValue {...}
ベタにJSONのデータ構造そのままですね。
それぞれcase classなので、このままでも使うことができますが、ちょっと不便です。
そこで、任意の型との相互変換を行う関数として、次の2つが用意されています。
def toJson[T](o: T)(implicit tjs: Writes[T]): JsValue = tjs.writes(o)
def fromJson[T](json: JsValue)(implicit fjs: Reads[T]): T = fjs.reads(o)
Writes[T]がT型からJsValueへの変換を、
Reads[T]がJsValueからT型への変換を提供するオブジェクトの型になっています。
それぞれimplicitとなっているので、
import play.api.json.Reads._
import play.api.json.Writes._
などとしておけば、
assert (toJson(Map("a"->2)).toString =="""{"a":2.0}""")
assert (fromJson[Int](parseJson("1")) == 1)
assert (fromJson[Map[String,SortedSet[Int]]](parseJson("""{"a":[1,5,3]}""")) == Map("a" -> SortedSet(1,3,5)))
assert (fromJson[Map[String,List[Int]]](parseJson("""{"a":[1,5,3]}""")) == Map("a" -> List(1,5,3)))
といった形で、よくある感じの型にはデフォルトで変換プロトコルが提供されていて、
簡単に使うことができます。
ちなみにWrites[T] とReads[T]はこんな感じです。
trait Writes[T] {
def writes(o: T): JsValue
}
trait Reads[T] {
def reads(json: JsValue): T
}
(Writes Readsの他に次のようなFormatという型も用意されています。おそらく今後これを実装したobjectが提供されるんだと思います。
trait Format[T] extends Writes[T] with Reads[T]
)
カスタム変換プロトコル
次に自分の好きな変換を提供する方法について考えてみます。
まずは、Reads[T]の実装をみてみます。
シンプルな例としてReads[Boolean]は次のようになっています。
implicit object BooleanReads extends Reads[Boolean] {
def reads(json: JsValue) = json match {
case JsBoolean(b) => b
case _ => throw new RuntimeException("Boolean expected")
}
}
def reads(json: JsValue):Boolean
な型のメソッドを持つReads[Boolean]なオブジェクトをimplicitで提供するだけですね。
変換したい型が、List[T]などのパラメータ化された型の場合はもう少し複雑になります。
List[Int]、List[Boolean]などについて個別にReads[List[Int]]などを用意していけば、
Reads[Boolean]と同じ形に書けますが、これだとList[List[List[Int]]]などのネストを考えると
事前にすべて用意する訳にはいかなそうです。
そこで、Tがなにかはわからないけれど、T(例えばIntだったりする何か)について変換する方法を
教えてくれれば、List[T]の変換方法を教えましょう、という形の関数を書くことになります。
Tの変換方法とはつまりReads[T]型のオブジェクトで、
List[T]の変換方法とはReads[List[T]]型のオブジェクトです。
なので型でいうと、Reads[T]型のオブジェクトを受け取って、Reads[List[T]]型のオブジェクトを返す関数を
書くことになります。実際のソースの該当部分は次のようになります。
implicit def listReads[T](implicit fmt: Reads[T]): Reads[List[T]] = new Reads[List[T]] {
def reads(json: JsValue) = json match {
case JsArray(ts) => ts.map(t => fromJson(t)(fmt))
case _ => throw new RuntimeException("List expected")
}
}
ここで、implicit fmt: Reads[T]と、Reads[T]型の引数についてもimplicitが指定してあるので、
例えば先ほどのimplicit object BooleanReads extends Reads[Boolean]
などが提供されていれば、listReadsにBooleanReadsが暗黙に自動的に供給されて、
Reads[List[Boolean]] も自動的に供給されることになります。
この仕組みを使って、ここでは試しにReads[Either[A, B]]な変換方法の提供を考えてみたいと思います。
JSONは基本動的型付けなので、[1, 2, null]のように、
ひとつの配列の中に様々な型の値が一緒に入っていることがあります。
連想配列であれば、違うキーに対しては、むしろ別の型の値が入っていることの方が普通でしょう。
例えば、{"name":"milk", "price":150}のように。
こういったものでもEither型への変換ができればすこしだけ便利かもしれません。
Either[A,B]は型パラメータを二つとるので、変換方法もReads[A]とReads[B]の2種類が必要です。
fromJsonを使って型の変換に失敗したときは例外が投げられるので、それをキャッチして
分岐してもいいのですが、成功したときはSome[A]、変換に失敗したときなNoneを返してくれる
便利なasOptメソッドがあるのでここではそれを使ってみました。
implicit def eitherReads[A,B](implicit fmtA: Reads[A], fmtB: Reads[B]):Reads[Either[A, B]] =
new Reads[Either[A, B]] {
def reads(json: JsValue) =
json.asOpt[A](fmtA) match {
case Some(a) => Left(a)
case None => Right(fromJson[B](json)(fmtB))
}
}
assert (fromJson[Either[String,Int]](json.parseJson("""1""")) == Right(1))
assert (fromJson[Either[String,Int]](json.parseJson(""""a"""")) == Left("a"))
assert (fromJson[List[Either[Either[Boolean,String],Int]]](json.parseJson("""["a",true, 5]"""))
== List(Left(Right("a")), Left(Left(true)), Right(5.0)))
これでちょっとは便利になりましたが、Either型をたくさん使うと
どこかでパターンマッチをたくさん書くことになって、JsValueに対して
パターンマッチを書いていくのとあまり変わらないことになってしまいます。
なにより型の混ざった配列ならともかく、
{"name":"milk", "price":150}のような連想配列は
Map[String, Either[String,Int]]
に変換するのではなく、
case class Hoge(name:String, price:Int)
のような何らかのクラスに変換したいのが普通でしょう。
もちろん特定のcaseクラスへの変換を記述することはそれほど大変なことではありませんが、
case クラスがたくさんある場合は、ちょっと面倒そうです。
そんな時のために、sjsonでは、任意のcase クラスへの変換プロトコルを簡単に提供するための
便利な関数が用意されています。Scalaでは可変長の型引数はサポートされていないので、
case クラスのメンバの数に応じて、asProduct1、asProduct2、asProduct3...
といったメソッドが用意されています。
sjsonのソースでは、テンプレートを使ってこれらの定義が自動生成していますが、
ここではplay.api.json用に、asProduct3だけをポーティングしてみたいと思います。
まず、asProduct3のシグネチャは次のようになります。
def asProduct3[S, T1, T2, T3]
(f1: String, f2: String, f3: String)
(apply : (T1, T2, T3) => S)
(unapply : S => Product3[T1, T2, T3])
(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3])
: Format[S]
まず、型パラメータの[S, T1, T2, T3] です。
ひとつめのSは、変換対象のcase クラスです。
T1,T2,T3はそれぞれ、caseクラスのメンバ変数の型になります。
最初の引数、
(f1: String, f2: String, f3: String)
は、メンバ変数に体操するJSONでのキーになります。
メンバ変数の名前と同じものになることも多いでしょう。
次の二つの引数 applyとunapplyは、
(apply : (T1, T2, T3) => S)
(unapply : S => Product3[T1, T2, T3])
caseクラスのコンパニオンオブジェクトのapply unapplyメソッド
を受け取ります。
最後に、各メンバ変数の型ごとにReads[T1]やWrites[T1]を供給するために
Format[T1]をimplicitに受け取ります。
たとえば、case class Hoge(name:String, price:Int, flag:Boolean)
を、{"name":"...", "price":1234, "flag":true}に変換するのであれば、
asProduct3[Hoge, String, Int, Boolean]
("name", "price", "flag")
(Hoge.apply)
(Hoge.unapply)
といった引数を渡すだけで、
Format[Hoge]の実装を得ることができます。
asProduct3の実装は次のような感じになります。
def asProduct3[S, T1, T2, T3](f1: String, f2: String, f3: String)
(apply : (T1, T2, T3) => S)
(unapply : S => Product3[T1, T2, T3])
(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3])
= new Format[S]{
def writes(s: S) = {
val product = unapply(s)
JsObject(
Map(
(f1, toJson(product._1)),
(f2, toJson(product._2)),
(f3, toJson(product._3))
))
}
def reads(js: JsValue) = js match {
case JsObject(m) =>
apply(
fromJson[T1](m(f1)),
fromJson[T2](m(f2)),
fromJson[T3](m(f3))
)
case _ => throw new RuntimeException("object expected")
}
}
これを使えば、例えば次のようなcase クラスに対して、
case class Shop(store: String, item: String, price: Int)
次のように変換プロトコルを簡単に用意することができます。
object ShopProtocol {
import DefaultFormat._
implicit val ShopFormat: Format[Shop] =
asProduct3("store", "item", "price")(Shop)(Shop.unapply(_).get)
}
詳しくは、sjsonのgithubの該当部分をご覧ください。
https://github.com/debasishg/sjson/blob/master/src/main/scala/sjson/json/Generic.scala
以上です。
これを書いている間に日が変わってしまいました!ゴメンナサイ!!
次回12月8日は@hagikuratakeshiさんです。
よろしくお願いします!!
2010年12月11日土曜日
SQLAlchemyのモデルクラス用のFlaskコンバータを作ってみる
Flaskは、wsgiツールキット的なWerkzeugを基盤に構築されたフレームワークです。
Flaskではroutingの仕組みは、Werkzeugのものをほぼそのまま使い、
関数を簡単にコントローラとして公開できるようなデコレータが用意されています。
これはたとえば以下のように使います。
@app.route("/post/<int:post_id>")
def show_post(post_id):
return "hello"
<int:post_id>というところに注目してください。
この定義により、"/post/10"や"/post/5"のようなURLにマッチし、
show_post関数の引数post_idに、マッチした部分をintに変換し
10や5といった値がわたってくる事になります。
この<int:hoge>の部分は、Converterと呼ばれる仕組みで自作することができるようになっています。
今回は、SQLAlchemyとからめて、idを受け取って、特定のモデルクラスのインスタンスを
抽出するようなConverterを書いてみたいと思います。
モチベーションとしては、以下のようにIDをintとして受け取って、
そのidでインスタンスを検索し、なかったら404にするような操作を、
@app.route("/post/<int:post_id>")
def show_post(post_id):
post = Post.query.get(post_id)
if not post:
raise werkzeug.exceptions.NotFound()
return post.hoge()
次のように、モデルと同名のコンバータを指定する事で、
自動でIDの文字列からインスタンスをfetchして引数として渡し、
もし該当IDがなければ、自動で404としてくれれば、便利かなという感じです。
@app.route("/post") # idが該当しなければ404
def show_post(post):
return post.hoge()
まず準備として、FlaskアプリとSQLAlchemyの初期化を行います。
from flask import Flask, request, url_for, redirect
from flaskext.sqlalchemy import SQLAlchemy
from sqlalchemy import Table, Column, Integer, Unicode
from sqlalchemy.orm import mapper
from werkzeug.routing import IntegerConverter, ValidationError
app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///test.db"
db = SQLAlchemy(app)
アプリやデータベースの準備ができたら、
早速コンバータのベースクラスを定義してみましょう。
class BaseModelConverter(IntegerConverter):
def __init__(self, map):
super(BaseModelConverter, self).__init__(map)
def to_python(self, value):
id_ = super(BaseModelConverter, self).to_python(value)
obj = self.model.query.get(id_)
if not obj:
raise ValidationError()
return obj
def to_url(self, value):
return str(value.id)
IntegerConverterを継承するので、正規表現的に\d+にマッチするかのチェックが
まず行われます。
to_pythonメソッドでは、valueつまりマッチした部分の文字列を受け取ります。
IntegerConverter.to_pythonに渡し、int値を得ます。(この時点で失敗すればその中でValidationErrorが投げられます)
このint値、つまりIDをもとにself.model.query.get(id_)により、インスタンスを取得し、
Noneが得られた場合はValidationErrorとします。
to_urlメソッドの方は、その逆に、インスタンスを受けて、そのidをstrにしたものを返すだけです。
そして、モデルを定義するたびにコンバータを追加していると手間なので、
特定のベースモデルクラスを継承したモデルを定義すると自動で同名のコンバータを
追加するようなベースクラスを用意します。
ベースクラスとそのメタクラスの定義は次のようになります。
class BaseModelType(type):
def __init__(cls, name, bases, attrs):
super(BaseModelType, cls).__init__(name, bases, attrs)
if name == 'BaseModel':
return
conv = type(name + "Converter", (BaseModelConverter,), dict(model=cls))
app.url_map.converters[name] = conv
class BaseModel(object):
__metaclass__ = BaseModelType
BaseModelType.__init__の中では、
BaseModelのコンバータは不要なので、とりあえず名前で
BaseModelかどうかのチェックを行います。
そうでなければ、そのモデルの名前 + "Converter"
たとえば UserConverterのような名前の、BaseModelConverterを継承したクラスを生成します。
これは、
class UserConverter(BaseModelCOnverter):
model = User
と同等です。
そして得られたコンバータクラスを、app.url_map.convertersに、モデルと同じ名前で登録します。
BaseModelは、BaseModelTypeをメタクラスとして持ち後は空のクラスです。
ではこれをつかって試しにUserクラスを定義します。
user_table = Table(
"user_table", db.metadata,
Column('id', Integer, primary_key=True),
Column('name', Unicode(100)),
)
class User(BaseModel):
query = db.session.query_property()
def __init__(self, name):
self.name = name
mapper(User, user_table)
とりあえず、上記のように、idとnameだけを持つモデルを定義してみました。
あとはこれをつかったコントローラを書きます。
今回は紙面の都合上テンプレートの使用は省略して
直接文字列を返しておきます。
@app.route("/detail/<User:user>", methods=('GET',))
def detail(user):
return """
<html><body>
<h1>%s</h1>
</body></html>
""" % user.name
もう、説明することがないくらいシンプルなコントローラです。
あとは、Userインスタンスを登録し、そのリストを一覧でだせるようにしましょう。
@app.route("/", methods=('GET',))
def users():
userlist = "".join(
'<a href="http://www.blogger.com/%s">%s</a>' % (
url_for('detail', user=user), user.name)
for user in User.query.all())
return """
<html><body>
%s
<hr />
<form method="post" action="/">
<input type="text" name="name">
<input type="submit">
</form>
</body></html>
""" % userlist
@app.route("/", methods=('POST',))
def add_user():
user = User(request.form['name'])
db.session.add(user)
db.session.commit()
return redirect(url_for('users'))
url_for('detail', user=user)の部分で、UserConverter.to_urlが内部で呼び出され、
適切なURL、たとえば/detail/1 といったURLが生成されることになります。
これで準備はととのいました。
あとは、実行するだけです。
if __name__ == "__main__":
db.metadata.create_all(db.engine)
app.debug=True
app.run(host="127.0.0.1",port=8000)
と最後にかいて、ファイル全体をmain.pyなどの適当な名前で保存し、
python main.py
とすればサーバが立ち上がります。
適当にユーザを追加して動作を確認しましょう!
今回はモデルのIDをマッチする単純なものでしたが、
id以外のカラムにマッチしたり、難読化したidにマッチしたり、
制限時間付きのhmacトークンを埋め込むURLを生成したりといったことが
コンバータの追加で行う事ができます。ちょっとしたことではありますが、
コンバータで抽出、整合性のチェックを行い、失敗すれば404にしてくれるのは
地味に便利だったりします。
皆さんもFlaskやWerkzeugを使って便利なコンバータを使って、
すてきな Python Web FWライフを!
ということでつぎは、@r_rudi にバトンを渡したいと思います。よろしく!>@r_rudi
2009年12月16日水曜日
zope.sqlalchemyの紹介
>>> from sqlalchemy import create_engine
>>> engine = create_engine("mysql://hoge", convert_unicode=True)
>>> from sqlalchemy.orm import scoped_session, sessionmaker]
>>> from zope.sqlalchemy import ZopeTransactionExtension
>>> Session = scoped_session(sessionmaker(bind=engine,
... twophase=True, extension=ZopeTransactionExtension()))
>>> session = Session()
>>> session.add(Hoge(name='fuga'))
>>> session.query(Hoge).all()
[]
>>> import transaction
>>> transaction.commit()
とこんな感じの使い方になるようです。
(詳しくはzope.sqlalchemyを参照してください。)
ポイントは、
sessionmaker(bind=engine,
twophase=True, extension=ZopeTransactionExtension())
の部分と
>>> import transaction
>>> transaction.commit()
のところです。
コードの説明に入るまえに、そもそもなぜトランザクションの統合が必要になるか、ということについて簡単に説明します。
Wikipediaのトランザクションの項によると、
"トランザクション (transaction) とは、分ける事の出来ない一連の情報処理の単位である"とあります。
つまりひとつのトランザクションに含まれる処理であれば、全部が成功もしくは全部が失敗のどちらかになるべきで、一部が失敗して一部が成功した、といった状態になったら困るわけです。これを実現するために、ひとつの
トランザクション処理の途中で、なんらかの不都合が発生した場合、そこまでの処理をすべてなかったことにするロールバックや、すべての処理が成功した段階で、変更結果を永続化させるコミットの機能がZODBやRDBMSにより提供されます。
ZopeのZODBはトランザクションをサポートしており、作法に則ったやり方でZODBにアクセスすれば、処理の途中で例外が発生した場合ロールバックされ、一貫性が保たれます。
しかし、そこでロールバックされるのは当然ZODBに対する書き込み操作のみで、もし直接外部のRDBMSに対して書き込みを行っていた場合、その処理まで自動でロールバックされるわけではありません。すると、Zope/Ploneとしては処理が途中で失敗したのでロールバックを行い、ZODBの中身的には変更が無かったことになっているのに、外部のRDBMS には処理が成功したかのように変更が書き込まれてしまう、といった結果になる可能性があります。多くの場合において、これは望んだ結果ではないでしょう。
これを防ぐには、ZODBとRDBMSに対するふたつのトランザクションを統合し、ZODBに対する処理とRDBMSに対する処理が、両方成功するか、両方失敗するか、どちらかであるようにする必要があります。
これを実現する中核となるのが、zope.sqlalchemy.ZopeTransactionExtensionです。これはSQLAlchemyの
extending-sessionという機能を利用したもので、
sqlalchemy.orm.interfaces.SessionExtensionを継承(or実装。ここらへんはPythonなので微妙なところですね。)したクラスです。このクラスを使用することにより、zope.sqlalchemyはセッションの開始や、セッションの中でオブジェクトの追加や変更、削除などをフックすることができます。
でもって、セッションの開始でTwoPhaseSessionDataManagerインスタンスを作成し、zope_transaction.get().join(TwoPhaseSessionDataManager(session, state))
のような感じでzopeのトランザクションに結びつけます。
そして、SQLAlchemyのセッションでオブジェクトの変更などをフックして、状態を初期状態のSTATUS_ACTIVEからSTATUS_CHANGEDに変更します。
そんでもって
>>> import transaction
>>> transaction.commit()
によりzopeのトランザクションがコミットされた場合は、TwoPhaseSessionDataManagerのメソッドが呼び出され、
もし状態がSTATUS_CHANGEDになっていれば、二相コミットを行います。
STATUS_ACTIVE/STATUS_CHANGEDと、2相コミットに関して補足します。
2相コミットとは、複数のデータベースが存在する時に、各トランザクションを統合して、全体として成功/失敗のどちらかにするための技術です。ちょっと説明が適当なので、
詳しくは
Wikipedia:"2相コミット"を参照してください。
例えば、データベースAとBがあった場合、よくありそうな問題としては、全部の処理がうまくいったので、
まずAにコミットして成功し、つぎにBに対してコミットを行おうとしたら、コミットに失敗してしまった、という状況です。
これを防ぐために2相コミットでは、トランザクションのコミットしようとするとき、
参加しているデータベースに対して、コミットが可能であるか、まず全員に質問します。ここで、全員から同意が得られれば、全体をあらためてコミットします。逆に、どれかひとつでも同意が得られなかった場合は、全体をロールバックさせます。この2相コミットを使用すれば、DBMSが落ちる、DBMSとのネットワークが切れるなどの事態が肝心なタイミングで発生しなければ、全体の一貫性を保つことができます。
この2相コミットは、それなりに面倒な処理です。RDBMSの方に書き込みを行わなかった場合、そもそも2相コミットを行う必要がありません。このためにzope.sqlalchemyでは、SQLAlchemyのセッションに変更操作を行ったかどうかを、STATUS_ACTIVE/STATUS_CHANGEDという状態により管理し、zopeのtransaction.commit()時にSTATUS_ACTIVEのままであれば2相コミットを省略するような動きになっているようです。
STATUS_ACTIVE/STATUS_CHANGEDの状態は、sqlalchemy.orm.interfaces.SessionExtensionのafter_bulk_updateメソッドなどが呼び出されるタイミングで、STATUS_CHANGEDに変更されます。
このフックメソッドは、次のようにORMを通さないでSQLが発行された場合は呼び出されません。
(よびだしてくれればいいような気がしますが。)
>>> conn = session.connection()
>>> conn.execute(update_expression)
この問題を防ぐため、このような場合には、つぎのように明示的にSTATUS_CHANGEDをセットします。
>>> from zope.sqlalchemy import mark_changed
>>> mark_changed(session)
<追記 2009-12-18>
ということで、ということで、次のバトンは昔からブログでお世話になっているPythonの大先輩のnakagamiさんにお願いします。
2009年12月6日日曜日
slime + swank-clojureの続き
どうもClojure1.1との組み合わせの問題のようなので
http://github.com/stuarthalloway/swank-clojure/tree/clojure-1.1
のswank-clojureを使ったらうまく動いた。
(追記)
結局
http://github.com/technomancy/swank-clojure/tree/clojure-1.1
の方に変更した。
2009年12月5日土曜日
slime + swank-clojureが動かない
最近のslimeとswank-clojureの組み合わせがこける。
SLIME REPL broken
を参考に、
"/home/hokari/opt/swank-clojure/src/main/clojure/swank/core/protocol.clj"
を
@@ -4,6 +4,20 @@
;; Read forms
+ (def #^{:private true}
+ *percent-re* #"%")
+
+(defn- fix-percent
+ "Replace double colons with a /."
+ ([text] (.replaceAll (re-matcher *percent-re* text) "?")))
+
+(def #^{:private true}
+ *double-colon-re* #"::")
+
+(defn- fix-double-colon
+ "Replace double colons with a /."
+ ([text] (.replaceAll (re-matcher *double-colon-re* text) "/")))
+
(def #^{:private true}
*namespace-re* #"(^\(:emacs-rex \([a-zA-Z][a-zA-Z0-9]+):")
(defn- fix-namespace
@@ -50,7 +64,7 @@
([#^java.io.Reader reader]
(let [len (Integer/parseInt (read-chars reader 6 read-fail-exception) 16)
msg (read-chars reader len read-fail-exception)
- form (read-string (fix-namespace msg))]
+ form (read-string (fix-namespace (fix-double-colon (fix-percent msg))))]
(if (seq? form)
(deep-replace {'t true} form)
form))))
のようなかんじにしたら動いた。
Common LispとClojureで"%"や"::"の意味とか許可/不許可が違うせい、
ということみたい。