ruston 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cf5c0f1352fca5ac06d4941ed73e96eaf9f7094e2cc87e48ac731224e9756850
+  data.tar.gz: 7774865e19f036dc54fcd0f087ff8dff7af7ee3a291f04f7a541796ace67a8d1
+SHA512:
+  metadata.gz: b8ba536beb1a1b3a18af9061ab073622edee3222161281a3146e18d28eda1872fe404371891cc45f82dea28c89ceb6172ceac4b0d29e55da3b69b23cf400b134
+  data.tar.gz: 263de613a6e15a1179fc2ab3e9e4d877c0266ffa8ed3da1ae697b0b9f251ac214fd7b6adb527e344618a95f7c382dc609491367b059bbf63e2e417edf65c1d36

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+/target/
+
+*.gem

data/.ruby-version

@@ -0,0 +1 @@
+3.1.1

data/Cargo.lock

@@ -0,0 +1,398 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "ansi_term"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.59.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bd2a9a458e8f4304c52c43ebb0cfbd520289f8379a52e329a38afda99bf8eb8"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "clang-sys",
+ "clap",
+ "env_logger",
+ "lazy_static",
+ "lazycell",
+ "log",
+ "peeking_take_while",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "which",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "cc"
+version = "1.0.73"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "clang-sys"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a050e2153c5be08febd6734e29298e844fdb0fa21aeddd63b4eb7baa106c69b"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "clap"
+version = "2.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
+dependencies = [
+ "ansi_term",
+ "atty",
+ "bitflags",
+ "strsim",
+ "textwrap",
+ "unicode-width",
+ "vec_map",
+]
+
+[[package]]
+name = "coffret"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efb0b42fe7c89fec1939af9293f94403f32bab4ac86769dbd8362d34c40e649c"
+dependencies = [
+ "libc",
+ "rb-sys",
+]
+
+[[package]]
+name = "either"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+
+[[package]]
+name = "env_logger"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b2cf0344971ee6c64c31be0d530793fba457d322dfec2810c453d0ef228f9c3"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "lazycell"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
+
+[[package]]
+name = "libc"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
+
+[[package]]
+name = "libloading"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efbc0f03f9a775e9f6aed295c6a1ba2253c5757a9e03d55c6caa46a681abcddd"
+dependencies = [
+ "cfg-if",
+ "winapi",
+]
+
+[[package]]
+name = "linkify"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d9967eb7d0bc31c39c6f52e8fce42991c0cd1f7a2078326f0b7a399a584c8d"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "log"
+version = "0.4.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "nom"
+version = "7.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8903e5a29a317527874d0402f867152a3d21c908bb0b933e416c65e301d4c36"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "peeking_take_while"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1df8c4ec4b0627e53bdf214615ad287367e482558cf84b109250b37464dc03ae"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c54b25569025b7fc9651de43004ae593a75ad88543b17178aa5e1b9c4f15f56f"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1feb54ed693b93a84e14094943b84b7c4eae204c512b7ccb95ab0c66d278ad1"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rb-sys"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5465c5bd695ef70959b91b4ca9cfd515e9af012f6d9f0ae46f09fa4bcc3b722"
+dependencies = [
+ "bindgen",
+ "cc",
+ "lazy_static",
+ "linkify",
+ "pkg-config",
+ "shell-words",
+]
+
+[[package]]
+name = "regex"
+version = "1.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d83f127d94bdbcda4c8cc2e50f6f84f4b611f69c902699ca385a39c3a75f9ff1"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49b3de9ec5dc0a3417da371aab17d729997c15010e7fd24ff707773a33bddb64"
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
+[[package]]
+name = "ruston"
+version = "0.1.0"
+dependencies = [
+ "coffret",
+ "libc",
+ "rb-sys",
+]
+
+[[package]]
+name = "shell-words"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
+
+[[package]]
+name = "shlex"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
+
+[[package]]
+name = "strsim"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+
+[[package]]
+name = "termcolor"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bd2fe26506023ed7b5e1e315add59d6f584c621d037f9368fea9cfb988f368c"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+
+[[package]]
+name = "vec_map"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
+
+[[package]]
+name = "which"
+version = "4.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c4fb54e6113b6a8772ee41c3404fb0301ac79604489467e0a9ce1f3e97c24ae"
+dependencies = [
+ "either",
+ "lazy_static",
+ "libc",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

data/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "ruston"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["lib", "cdylib"]
+
+[dependencies]
+libc = "^0.2"
+rb-sys = { version = "^0.9", features = ["link-ruby"] }
+coffret = "0.0.3"

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in ruston.gemspec
+gemspec
+
+gem "bundler", ">= 1.17"
+gem "rake", ">= 10.0"

data/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: .
+  specs:
+    ruston (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (13.0.6)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  bundler (>= 1.17)
+  rake (>= 10.0)
+  ruston!
+
+BUNDLED WITH
+   2.4.0.dev

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Uchio Kondo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Ruston
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/ruston`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ruston'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ruston
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/udzura/ruston.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ruston"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/lex.rs

@@ -0,0 +1,11 @@
+extern crate ruston;
+
+fn main() {
+    let json = "
+{\"Hello\": true, \"world\": [1, 2, 3]}
+";
+    let ret = ruston::json::lexer::Lex::run(json.to_string())
+        .unwrap()
+        .tokens;
+    dbg!(ret);
+}

data/examples/parser.rs

@@ -0,0 +1,30 @@
+extern crate ruston;
+
+fn main() {
+    let ret = ruston::json::parse("true");
+    dbg!(ret);
+
+    let ret = ruston::json::parse("123");
+    dbg!(ret);
+
+    let ret = ruston::json::parse("\"Hola\"");
+    dbg!(ret);
+
+    let ret = ruston::json::parse("[1, 2, 3, false]");
+    dbg!(ret);
+
+    let ret = ruston::json::parse("{\"foo\": true, \"bar\": 123}");
+    dbg!(ret);
+
+    let nested = "
+{
+  \"id\": 1,
+  \"user\": {
+    \"name\": \"Akubi\",
+    \"age\": 3,
+  }
+}
+";
+    let ret = ruston::json::parse(nested);
+    dbg!(ret);
+}

data/examples/rb/parsejson.rb

@@ -0,0 +1,14 @@
+require 'ruston'
+require 'ruston.so'
+
+json = <<JSON
+[
+{"id": 1,
+ "name": "udzura"},
+{"id": 2,
+ "name": "akubi"}
+]
+JSON
+
+ret = Ruston.new.parse(json)
+p ret

data/examples/ruby_run.rs

@@ -0,0 +1,23 @@
+extern crate ruston;
+
+fn main() {
+    //     let json = "
+    // {\"Hello\": true, \"world\": [1, 2, 3]}
+    // ";
+
+    let json = "true";
+    let ruby = ruston::ruby::parse_into_ruby(json.to_string()).unwrap();
+    unsafe { rb::rb_p(ruby) };
+
+    let json = "\"Rubyist?\"";
+    let ruby = ruston::ruby::parse_into_ruby(json.to_string()).unwrap();
+    unsafe { rb::rb_p(ruby) };
+
+    let json = "[\"Rubyist?\", 12, null]";
+    let ruby = ruston::ruby::parse_into_ruby(json.to_string()).unwrap();
+    unsafe { rb::rb_p(ruby) };
+
+    let json = "{\"Rubyist?\": true}";
+    let ruby = ruston::ruby::parse_into_ruby(json.to_string()).unwrap();
+    unsafe { rb::rb_p(ruby) };
+}

data/lib/ruston/version.rb

@@ -0,0 +1,3 @@
+class Ruston
+  VERSION = "0.0.1"
+end

data/lib/ruston.rb

@@ -0,0 +1,7 @@
+require "ruston/version"
+require "ruston.so"
+
+class Ruston
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/ruston.gemspec

@@ -0,0 +1,25 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "ruston/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruston"
+  spec.version       = Ruston::VERSION
+  spec.authors       = ["Uchio Kondo"]
+  spec.email         = ["udzura@udzura.jp"]
+
+  spec.summary       = %q{Sample Rust-made gem to parse simple JSON...}
+  spec.description   = %q{Sample Rust-made gem to parse simple JSON...}
+  spec.homepage      = "https://github.com/udzura/ruston"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  # spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["Cargo.toml"]
+end

data/src/json.rs

@@ -0,0 +1,379 @@
+use std::{collections::HashMap, fmt::Display, hash::Hash};
+
+#[derive(Debug, Clone)]
+pub struct Token {
+    pub start: usize,
+    pub end: usize,
+    pub lexeme: String,
+    pub ty: TokenType,
+}
+
+impl Token {
+    fn is(&self, ty: TokenType) -> bool {
+        self.ty == ty
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum TokenType {
+    BraceOpen,
+    BraceClose,
+    BracketOpen,
+    BracketClose,
+    Colon,
+    Comma,
+    Number,
+    StrLit,
+    Null,
+    True,
+    False,
+
+    EoF,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Value {
+    Null,
+    True,
+    False,
+    Int(i32),
+    Str(String),
+    Array(Vec<Value>),
+    Object(usize, HashMap<Value, Value>),
+}
+
+impl Hash for Value {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        match self {
+            Self::Object(val, _) => val.hash(state),
+            _ => core::mem::discriminant(self).hash(state),
+        };
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct JsonError {
+    pub message: String,
+}
+
+impl JsonError {
+    pub fn raise(message: impl Into<String>) -> Self {
+        Self {
+            message: message.into(),
+        }
+    }
+}
+
+impl Display for JsonError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.message)
+    }
+}
+
+impl std::error::Error for JsonError {}
+
+pub mod lexer {
+    use super::*;
+
+    #[derive(Debug, Default)]
+    pub struct Lex {
+        pub stream: String,
+        pub start: usize,
+        pub current: usize,
+        pub line: usize,
+
+        pub tokens: Vec<Token>,
+    }
+
+    impl Lex {
+        pub fn run(stream: String) -> Result<Self, JsonError> {
+            let mut lex = Self {
+                stream,
+                ..Default::default()
+            };
+
+            lex.process()?;
+            Ok(lex)
+        }
+
+        fn process(&mut self) -> Result<(), JsonError> {
+            loop {
+                match self.advance()? {
+                    '{' => self.push_token(TokenType::BraceOpen),
+                    '}' => self.push_token(TokenType::BraceClose),
+                    '[' => self.push_token(TokenType::BracketOpen),
+                    ']' => self.push_token(TokenType::BracketClose),
+                    ':' => self.push_token(TokenType::Colon),
+                    ',' => self.push_token(TokenType::Comma),
+                    't' => {
+                        self.matches("rue")?;
+                        self.push_token(TokenType::True)
+                    }
+                    'f' => {
+                        self.matches("alse")?;
+                        self.push_token(TokenType::False)
+                    }
+                    'n' => {
+                        self.matches("ull")?;
+                        self.push_token(TokenType::Null)
+                    }
+                    '"' => loop {
+                        let c = self
+                            .advance()
+                            .or_else(|_| Err(JsonError::raise("quote unmet")))?;
+                        if c == '"' {
+                            self.push_token(TokenType::StrLit);
+                            break;
+                        }
+                    },
+                    '\n' => {
+                        self.line += 1;
+                        self.start = self.current
+                    }
+                    ' ' | '\t' => self.start = self.current,
+                    '1'..='9' => {
+                        while is_digit(self.peek()) {
+                            self.advance()?;
+                        }
+                        self.push_token(TokenType::Number);
+                    }
+                    c => return Err(JsonError::raise(format!("unexpected token {}", c))),
+                }
+                if self.reached_end() {
+                    self.push_token(TokenType::EoF);
+                    break;
+                }
+            }
+            Ok(())
+        }
+
+        fn peek(&mut self) -> Option<char> {
+            self.stream
+                .chars()
+                .collect::<Vec<char>>()
+                .get(self.current)
+                .map(|c| *c)
+        }
+
+        fn matches(&mut self, s: &str) -> Result<(), JsonError> {
+            for c in s.chars() {
+                let c2 = self.advance()?;
+                if c2 != c {
+                    return Err(JsonError::raise(format!("unexpected character {}", c2)));
+                }
+            }
+
+            Ok(())
+        }
+
+        fn advance(&mut self) -> Result<char, JsonError> {
+            let c = self.peek().ok_or_else(|| JsonError::raise("EoF"))?;
+            // eprintln!("process: {}", c);
+            self.current += 1;
+            Ok(c)
+        }
+
+        fn reached_end(&mut self) -> bool {
+            self.current >= self.stream.len()
+        }
+
+        fn push_token(&mut self, ty: TokenType) {
+            let token = Token {
+                start: self.start,
+                end: self.current,
+                lexeme: (&self.stream[self.start..self.current]).to_string(),
+                ty,
+            };
+
+            // eprintln!("pusing: {:?}: {}", &token.ty, &token.lexeme);
+            self.tokens.push(token);
+            self.start = self.current
+        }
+    }
+
+    fn is_digit(c: Option<char>) -> bool {
+        match c {
+            Some(c) => c >= '0' && c <= '9',
+            None => false,
+        }
+    }
+}
+
+pub mod parser {
+    use super::*;
+
+    #[derive(Debug)]
+    pub struct Parser {
+        pub stream: Vec<Token>,
+        pub current: usize,
+        pub value: Value,
+
+        next_object_id: usize,
+    }
+
+    impl Parser {
+        pub fn run(stream: Vec<Token>) -> Result<Self, JsonError> {
+            let mut parser = Self {
+                stream,
+                current: 0,
+                value: Value::Null,
+                next_object_id: (1 << 16),
+            };
+
+            parser.process()?;
+            Ok(parser)
+        }
+
+        fn process(&mut self) -> Result<(), JsonError> {
+            self.value = self.process_value()?;
+
+            if !self.reached_end()? {
+                return Err(JsonError::raise("JSON has continued form"));
+            }
+
+            Ok(())
+        }
+
+        fn process_value(&mut self) -> Result<Value, JsonError> {
+            use TokenType::*;
+            let token = self.succ(1)?;
+            let value = match &token.ty {
+                Null => Value::Null,
+                True => Value::True,
+                False => Value::False,
+                Number => Value::Int(token.lexeme.parse().unwrap()),
+                StrLit => {
+                    let len = token.lexeme.len();
+                    Value::Str((&token.lexeme[1..(len - 1)]).to_string())
+                }
+                BracketOpen => self.array()?,
+                BraceOpen => self.object()?,
+
+                t => {
+                    todo!("Unexpected token: {:?}", &t)
+                }
+            };
+            Ok(value)
+        }
+
+        fn array(&mut self) -> Result<Value, JsonError> {
+            use TokenType::*;
+            let mut ar = Vec::new();
+            loop {
+                match self.peek(0) {
+                    Some(t) => match &t.ty {
+                        EoF => return Err(JsonError::raise("EoF")),
+                        BracketClose => {
+                            self.succ(1)?;
+                            break;
+                        }
+                        _ => {
+                            let v = self.process_value()?;
+                            ar.push(v);
+                            match self.peek(0) {
+                                None => return Err(JsonError::raise("EoF")),
+                                Some(t) => {
+                                    if t.is(Comma) {
+                                        self.succ(1)?;
+                                        let n = self.peek(0);
+                                        if n.is_none() {
+                                            return Err(JsonError::raise("EoF"));
+                                        }
+                                        if n.unwrap().is(BracketClose) {
+                                            return Err(JsonError::raise("Unexpected ]"));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    None => return Err(JsonError::raise("EoF")),
+                }
+            }
+            Ok(Value::Array(ar))
+        }
+
+        fn object(&mut self) -> Result<Value, JsonError> {
+            use TokenType::*;
+            let mut ha = HashMap::new();
+            loop {
+                match self.peek(0) {
+                    Some(t) => match &t.ty {
+                        EoF => return Err(JsonError::raise("EoF")),
+                        BraceClose => {
+                            self.succ(1)?;
+                            break;
+                        }
+                        _ => {
+                            let k = self.process_value()?;
+                            match self.peek(0) {
+                                None => return Err(JsonError::raise("EoF")),
+                                Some(t) => {
+                                    if t.is(Colon) {
+                                        self.succ(1)?;
+                                    } else {
+                                        return Err(JsonError::raise(format!(
+                                            "Unexpected token {:?}",
+                                            t.ty
+                                        )));
+                                    }
+                                }
+                            }
+                            let v = self.process_value()?;
+                            ha.insert(k, v);
+                            match self.peek(0) {
+                                None => return Err(JsonError::raise("EoF")),
+                                Some(t) => match t.ty {
+                                    BraceClose => {
+                                        continue;
+                                    }
+                                    Comma => {
+                                        self.succ(1)?;
+                                        continue;
+                                    }
+                                    other => {
+                                        return Err(JsonError::raise(format!(
+                                            "Unexpected token {:?}",
+                                            other
+                                        )));
+                                    }
+                                },
+                            }
+                        }
+                    },
+                    None => return Err(JsonError::raise("EoF")),
+                }
+            }
+            self.next_object_id += 1;
+            Ok(Value::Object(self.next_object_id, ha))
+        }
+
+        fn peek(&mut self, count: usize) -> Option<&Token> {
+            self.stream.get(self.current + count)
+        }
+
+        fn previous(&mut self) -> Option<&Token> {
+            if self.current == 0 {
+                return None;
+            }
+            self.stream.get(self.current - 1)
+        }
+
+        fn succ(&mut self, count: usize) -> Result<&Token, JsonError> {
+            self.current += count;
+            self.previous().ok_or_else(|| JsonError::raise("EoF"))
+        }
+
+        fn reached_end(&mut self) -> Result<bool, JsonError> {
+            self.peek(0)
+                .map(|tok| tok.is(TokenType::EoF))
+                .ok_or_else(|| JsonError::raise("EoF"))
+        }
+    }
+}
+
+pub fn parse(json: impl Into<String>) -> Value {
+    let tokens = self::lexer::Lex::run(json.into()).unwrap().tokens;
+    let value = self::parser::Parser::run(tokens).unwrap().value;
+    value
+}

data/src/lib.rs

@@ -0,0 +1,81 @@
+pub mod json;
+pub mod ruby;
+
+use std::slice;
+
+use coffret::*;
+use rb_sys::*;
+
+pub struct RubyFn {
+    value: unsafe extern "C" fn() -> RubyValue,
+}
+
+impl From<RubyFn> for unsafe extern "C" fn() -> RubyValue {
+    fn from(from: RubyFn) -> Self {
+        from.value
+    }
+}
+
+impl From<unsafe extern "C" fn() -> RubyValue> for RubyFn {
+    fn from(from: unsafe extern "C" fn() -> RubyValue) -> Self {
+        RubyFn { value: from }
+    }
+}
+
+impl From<unsafe extern "C" fn(RubyValue) -> RubyValue> for RubyFn {
+    fn from(from: unsafe extern "C" fn(RubyValue) -> RubyValue) -> Self {
+        let value = unsafe {
+            std::mem::transmute::<
+                unsafe extern "C" fn(RubyValue) -> RubyValue,
+                unsafe extern "C" fn() -> RubyValue,
+            >(from)
+        };
+        RubyFn { value }
+    }
+}
+
+impl From<unsafe extern "C" fn(RubyValue, RubyValue) -> RubyValue> for RubyFn {
+    fn from(from: unsafe extern "C" fn(RubyValue, RubyValue) -> RubyValue) -> Self {
+        let value = unsafe {
+            std::mem::transmute::<
+                unsafe extern "C" fn(RubyValue, RubyValue) -> RubyValue,
+                unsafe extern "C" fn() -> RubyValue,
+            >(from)
+        };
+        RubyFn { value }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn ruston_parse(_slf: RubyValue, json: RubyValue) -> RubyValue {
+    let mut json = Box::new(json);
+    let data: *const u8 = unsafe { rb_string_value_ptr(json.as_mut()) } as *const u8;
+    let len = unsafe { macros::RSTRING_LEN(json.as_ref().clone()) };
+
+    let bytes: &[u8] = unsafe { slice::from_raw_parts(data, len as usize) };
+    let json = String::from_utf8_lossy(bytes);
+
+    crate::ruby::parse_into_ruby(json.to_string()).unwrap()
+}
+
+fn init_ruston_internal() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Rust loaded");
+
+    let object = class::object_class();
+    let klass = class::define_class("Ruston", object);
+
+    let callback: RubyFn = (ruston_parse as unsafe extern "C" fn(u64, u64) -> u64).into();
+
+    class::define_method(klass, "parse", callback.into(), 1);
+
+    Ok(())
+}
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn Init_ruston() {
+    match init_ruston_internal() {
+        Err(e) => exception::rustly_raise(e.as_ref()),
+        Ok(_) => {}
+    }
+}

data/src/ruby.rs

@@ -0,0 +1,78 @@
+use crate::json;
+
+use rb::RubyValue;
+use rb_sys as rb;
+
+mod v {
+    use rb_sys::*;
+
+    #[repr(C)]
+    pub struct WrappedRubyValue {
+        value: u32,
+        padding: u32,
+    }
+
+    impl From<WrappedRubyValue> for RubyValue {
+        fn from(from: WrappedRubyValue) -> Self {
+            let v = unsafe { std::mem::transmute::<WrappedRubyValue, RubyValue>(from) };
+            v
+        }
+    }
+
+    #[allow(non_upper_case_globals)]
+    pub const True: WrappedRubyValue = WrappedRubyValue {
+        value: ruby_special_consts::RUBY_Qtrue as u32,
+        padding: 0,
+    };
+
+    #[allow(non_upper_case_globals)]
+    pub const False: WrappedRubyValue = WrappedRubyValue {
+        value: ruby_special_consts::RUBY_Qfalse as u32,
+        padding: 0,
+    };
+
+    #[allow(non_upper_case_globals)]
+    pub const Nil: WrappedRubyValue = WrappedRubyValue {
+        value: ruby_special_consts::RUBY_Qnil as u32,
+        padding: 0,
+    };
+}
+
+pub fn parse_into_ruby(json: String) -> Result<rb::RubyValue, Box<dyn std::error::Error>> {
+    unsafe { rb::ruby_init() };
+
+    let value = json::parse(json);
+    let ruby = walk(&value);
+    Ok(ruby)
+}
+
+fn walk(value: &json::Value) -> rb::RubyValue {
+    use json::Value::*;
+    match value {
+        Null => v::Nil.into(),
+        True => v::True.into(),
+        False => v::False.into(),
+        Int(i) => unsafe { rb::rb_int2big(*i as isize) },
+        Str(s) => unsafe {
+            let s = format!("{}\0", s);
+            rb::rb_utf8_str_new_cstr(s.as_ptr() as *const i8)
+        },
+        Array(v) => unsafe {
+            let ary = rb::rb_ary_new_capa(v.len() as i64);
+            for e in v.iter() {
+                let en = walk(e);
+                rb::rb_ary_push(ary, en);
+            }
+            ary
+        },
+        Object(_, ha) => unsafe {
+            let hash = rb::rb_hash_new();
+            for (k, v) in ha.iter() {
+                let rk = walk(k);
+                let rv = walk(v);
+                rb::rb_hash_aset(hash, rk, rv);
+            }
+            hash
+        },
+    }
+}

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: ruston
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Uchio Kondo
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-06-21 00:00:00.000000000 Z
+dependencies: []
+description: Sample Rust-made gem to parse simple JSON...
+email:
+- udzura@udzura.jp
+executables: []
+extensions:
+- Cargo.toml
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- Cargo.lock
+- Cargo.toml
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/lex.rs
+- examples/parser.rs
+- examples/rb/parsejson.rb
+- examples/ruby_run.rs
+- lib/ruston.rb
+- lib/ruston/version.rb
+- ruston.gemspec
+- src/json.rs
+- src/lib.rs
+- src/ruby.rs
+homepage: https://github.com/udzura/ruston
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.0.dev
+signing_key:
+specification_version: 4
+summary: Sample Rust-made gem to parse simple JSON...
+test_files: []