meta-ruby 3.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 884fc5bb96caeddf63c54c52d783fe32d9d87088
+  data.tar.gz: 253e3b4c1d462ce002152facea5231f4a39ce948
+SHA512:
+  metadata.gz: 56b0d554a1854a34a2332431975c2c94889461157c36822af3ce0f6260a865273ec367d77babbb0f24b400e1ebdbdde15b68c75d6176682893aa6f87419a3129
+  data.tar.gz: 107905c4b9eda3d6e7a3b3c959050f9ad7b6c3f8ce0d4e78872da502cd207163843eed1bde304dcf1aea836f5539ffed95b9e6bb2af80c5935d37e473e7c4d09

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org/"
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011-2015 InfraRuby Vision
+
+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,52 @@
+InfraRuby meta-ruby
+===================
+
+This gem provides classes to generate Ruby source code.
+
+
+Example
+-------
+
+	require "meta-ruby"
+
+	class Generator < MetaRuby::Generator
+		def initialize_sexp
+			s(:defn, "initialize", s(:args, "x", "y"),
+				s(:iasgn, "@x", s(:lvar, "x")),
+				s(:iasgn, "@y", s(:lvar, "y")),
+				s(:return),
+			)
+		end
+
+		def attr_reader_sexp(name)
+			s(:defn, name, s(:args),
+				s(:return, s(:ivar, "@#{name}")),
+			)
+		end
+
+		def xy_class_sexp
+			s(:class, "XY", nil,
+				initialize_sexp,
+				attr_reader_sexp("x"),
+				attr_reader_sexp("y"),
+			)
+		end
+	end
+
+	g = Generator.new
+
+	d = MetaRuby::Directory.new
+	d.instance_eval do
+		write("XY.rb", g.xy_class_sexp)
+	end
+
+
+Support
+-------
+
+InfraRuby Vision
+rubygems@infraruby.com
+
+http://infraruby.com/
+https://github.com/InfraRuby
+https://twitter.com/InfraRuby

data/Rakefile

@@ -0,0 +1,7 @@
+require "infraruby-task"
+
+loader = InfraRuby.task_loader
+loader.add_program("meta-hello")
+loader.load_tasks
+
+task "default" => "spec"

data/bin/meta-hello

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require "meta-ruby"
+
+class Generator < MetaRuby::Generator
+	## -> MetaRuby::Sexp
+	def hello_sexp
+		s(:call, nil, "puts", s(:arglist, s(:str, "hello, world")))
+	end
+end
+
+g = Generator.new
+
+d = MetaRuby::Directory.new
+d.instance_eval do
+	write("hello.rb", g.hello_sexp)
+end

data/lib/meta-ruby.rb

@@ -0,0 +1,6 @@
+require "infraruby-shim"
+
+require "s-expression"
+require "fab"
+
+InfraRuby.load_parent_library(__dir__)

data/meta-ruby.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+	s.platform = "ruby"
+	s.name = "meta-ruby"
+	s.version = "3.1.0"
+	s.licenses = ["MIT"]
+	s.author = "InfraRuby Vision"
+	s.email = "rubygems@infraruby.com"
+	s.homepage = "http://infraruby.com/"
+	s.summary = "Ruby metaprogramming with s-expressions"
+	s.description = "Ruby metaprogramming with s-expressions"
+	s.files = Dir["**/*"]
+	s.add_runtime_dependency "infraruby-shim", "~> 3.7"
+	s.add_runtime_dependency "s-expression", "~> 3.1"
+	s.add_runtime_dependency "fab", "~> 0.2"
+	s.add_development_dependency "infraruby-task", "~> 3.7"
+	s.add_development_dependency "rspec", "~> 3.0"
+end

data/pool/meta-ruby.cut

@@ -0,0 +1,118 @@
+## <>
+module MetaRuby
+end
+
+## <>
+##   :write: String, MetaRuby::Sexp -> void
+##   :write: String, String -> void
+##   :initialize: -> void
+##   :initialize: String -> void
+class MetaRuby::Directory < Fab::Directory
+end
+
+## <>
+##   :s: Symbol, *java.lang.Object? -> MetaRuby::Sexp
+##   :initialize: -> void
+class MetaRuby::Generator < Object
+end
+
+## <>
+##   :process: MetaRuby::Sexp -> String
+##   #process_array: MetaRuby::Sexp -> String
+##   #process_attrasgn: MetaRuby::Sexp -> String
+##   #process_call: MetaRuby::Sexp -> String
+##   #process_case: MetaRuby::Sexp -> String
+##   #process_cdecl: MetaRuby::Sexp -> String
+##   #process_class: MetaRuby::Sexp -> String
+##   #process_colon2: MetaRuby::Sexp -> String
+##   #process_colon3: MetaRuby::Sexp -> String
+##   #process_const: MetaRuby::Sexp -> String
+##   #process_defn: MetaRuby::Sexp -> String
+##   #process_ensure: MetaRuby::Sexp -> String
+##   #process_false: MetaRuby::Sexp -> String
+##   #process_hash: MetaRuby::Sexp -> String
+##   #process_iasgn: MetaRuby::Sexp -> String
+##   #process_if: MetaRuby::Sexp -> String
+##   #process_iter: MetaRuby::Sexp -> String
+##   #process_ivar: MetaRuby::Sexp -> String
+##   #process_lasgn: MetaRuby::Sexp -> String
+##   #process_lit: MetaRuby::Sexp -> String
+##   #process_lvar: MetaRuby::Sexp -> String
+##   #process_module: MetaRuby::Sexp -> String
+##   #process_nil: MetaRuby::Sexp -> String
+##   #process_op_asgn1: MetaRuby::Sexp -> String
+##   #process_op_asgn2: MetaRuby::Sexp -> String
+##   #process_op_asgn_and: MetaRuby::Sexp -> String
+##   #process_op_asgn_or: MetaRuby::Sexp -> String
+##   #process_rescue: MetaRuby::Sexp -> String
+##   #process_return: MetaRuby::Sexp -> String
+##   #process_sclass: MetaRuby::Sexp -> String
+##   #process_self: MetaRuby::Sexp -> String
+##   #process_str: MetaRuby::Sexp -> String
+##   #process_super: MetaRuby::Sexp -> String
+##   #process_true: MetaRuby::Sexp -> String
+##   #process_until: MetaRuby::Sexp -> String
+##   #process_while: MetaRuby::Sexp -> String
+##   #process_yield: MetaRuby::Sexp -> String
+##   :initialize: -> void
+class MetaRuby::Processor < Object
+end
+
+## <>
+##   INSTANCE: MetaRuby::SourceProcessor
+##   @depth: int32
+##   @level: int32
+##   .process: MetaRuby::Sexp -> String
+##   :initialize: -> void
+##   :process: MetaRuby::Sexp -> String
+##   :process_array: MetaRuby::Sexp -> String
+##   :process_attrasgn: MetaRuby::Sexp -> String
+##   :process_call: MetaRuby::Sexp -> String
+##   :process_case: MetaRuby::Sexp -> String
+##   :process_cdecl: MetaRuby::Sexp -> String
+##   :process_class: MetaRuby::Sexp -> String
+##   :process_colon2: MetaRuby::Sexp -> String
+##   :process_colon3: MetaRuby::Sexp -> String
+##   :process_const: MetaRuby::Sexp -> String
+##   :process_defn: MetaRuby::Sexp -> String
+##   :process_ensure: MetaRuby::Sexp -> String
+##   :process_false: MetaRuby::Sexp -> String
+##   :process_hash: MetaRuby::Sexp -> String
+##   :process_iasgn: MetaRuby::Sexp -> String
+##   :process_if: MetaRuby::Sexp -> String
+##   :process_iter: MetaRuby::Sexp -> String
+##   :process_ivar: MetaRuby::Sexp -> String
+##   :process_lasgn: MetaRuby::Sexp -> String
+##   :process_lit: MetaRuby::Sexp -> String
+##   :process_lvar: MetaRuby::Sexp -> String
+##   :process_module: MetaRuby::Sexp -> String
+##   :process_nil: MetaRuby::Sexp -> String
+##   :process_op_asgn1: MetaRuby::Sexp -> String
+##   :process_op_asgn2: MetaRuby::Sexp -> String
+##   :process_op_asgn_and: MetaRuby::Sexp -> String
+##   :process_op_asgn_or: MetaRuby::Sexp -> String
+##   :process_rescue: MetaRuby::Sexp -> String
+##   :process_return: MetaRuby::Sexp -> String
+##   :process_sclass: MetaRuby::Sexp -> String
+##   :process_self: MetaRuby::Sexp -> String
+##   :process_str: MetaRuby::Sexp -> String
+##   :process_super: MetaRuby::Sexp -> String
+##   :process_true: MetaRuby::Sexp -> String
+##   :process_until: MetaRuby::Sexp -> String
+##   :process_while: MetaRuby::Sexp -> String
+##   :process_yield: MetaRuby::Sexp -> String
+class MetaRuby::SourceProcessor < MetaRuby::Processor
+end
+
+## <>
+##   :initialize: Symbol -> void
+##   :initialize: Symbol, Array<java.lang.Object?> -> void
+##   :fetch_as_s: int32 -> String
+##   :fetch_as_s: Fixnum -> String
+##   :fetch_as_sexp: int32 -> MetaRuby::Sexp
+##   :fetch_as_sexp: Fixnum -> MetaRuby::Sexp
+##   :comments: -> Array<String>?
+##   :comments=: Array<String>? -> void
+class MetaRuby::Sexp < Sexp
+end
+

data/ruby/MetaRuby.rb

@@ -0,0 +1,3 @@
+## <>
+module MetaRuby
+end

data/ruby/MetaRuby/Directory.rb

@@ -0,0 +1,19 @@
+module MetaRuby
+	## <>
+	class Directory < Fab::Directory
+		## String, Sexp -> void
+		## String, String -> void
+		def write(path, o)
+			case o
+			when Sexp
+				s = SourceProcessor.process(o)
+			when String
+				s = o
+			else
+				raise RuntimeError
+			end
+			super(path, s)
+			return
+		end
+	end
+end

data/ruby/MetaRuby/Generator.rb

@@ -0,0 +1,9 @@
+module MetaRuby
+	## <>
+	class Generator
+		## Symbol, *java.lang.Object? -> Sexp
+		def s(type, *args)
+			return Sexp.__new__(type, args)
+		end
+	end
+end

data/ruby/MetaRuby/Processor.rb

@@ -0,0 +1,99 @@
+module MetaRuby
+	## <>
+	##   #process_array: Sexp -> String
+	##   #process_attrasgn: Sexp -> String
+	##   #process_call: Sexp -> String
+	##   #process_case: Sexp -> String
+	##   #process_cdecl: Sexp -> String
+	##   #process_class: Sexp -> String
+	##   #process_colon2: Sexp -> String
+	##   #process_colon3: Sexp -> String
+	##   #process_const: Sexp -> String
+	##   #process_defn: Sexp -> String
+	##   #process_ensure: Sexp -> String
+	##   #process_false: Sexp -> String
+	##   #process_hash: Sexp -> String
+	##   #process_iasgn: Sexp -> String
+	##   #process_if: Sexp -> String
+	##   #process_iter: Sexp -> String
+	##   #process_ivar: Sexp -> String
+	##   #process_lasgn: Sexp -> String
+	##   #process_lit: Sexp -> String
+	##   #process_lvar: Sexp -> String
+	##   #process_module: Sexp -> String
+	##   #process_nil: Sexp -> String
+	##   #process_op_asgn1: Sexp -> String
+	##   #process_op_asgn2: Sexp -> String
+	##   #process_op_asgn_and: Sexp -> String
+	##   #process_op_asgn_or: Sexp -> String
+	##   #process_rescue: Sexp -> String
+	##   #process_return: Sexp -> String
+	##   #process_sclass: Sexp -> String
+	##   #process_self: Sexp -> String
+	##   #process_str: Sexp -> String
+	##   #process_super: Sexp -> String
+	##   #process_true: Sexp -> String
+	##   #process_until: Sexp -> String
+	##   #process_while: Sexp -> String
+	##   #process_yield: Sexp -> String
+	class Processor
+		## % nojava
+		## <>
+		module X
+			class << self
+				## &(Processor, Sexp -> String) -> (Processor, Sexp -> String)
+				def process_block(&block)
+					return block
+				end
+			end
+
+			BLOCKS = {
+				:array => process_block { |processor, sexp| processor.process_array(sexp) },
+				:attrasgn => process_block { |processor, sexp| processor.process_attrasgn(sexp) },
+				:call => process_block { |processor, sexp| processor.process_call(sexp) },
+				:case => process_block { |processor, sexp| processor.process_case(sexp) },
+				:cdecl => process_block { |processor, sexp| processor.process_cdecl(sexp) },
+				:class => process_block { |processor, sexp| processor.process_class(sexp) },
+				:colon2 => process_block { |processor, sexp| processor.process_colon2(sexp) },
+				:colon3 => process_block { |processor, sexp| processor.process_colon3(sexp) },
+				:const => process_block { |processor, sexp| processor.process_const(sexp) },
+				:defn => process_block { |processor, sexp| processor.process_defn(sexp) },
+				:ensure => process_block { |processor, sexp| processor.process_ensure(sexp) },
+				:false => process_block { |processor, sexp| processor.process_false(sexp) },
+				:hash => process_block { |processor, sexp| processor.process_hash(sexp) },
+				:iasgn => process_block { |processor, sexp| processor.process_iasgn(sexp) },
+				:if => process_block { |processor, sexp| processor.process_if(sexp) },
+				:iter => process_block { |processor, sexp| processor.process_iter(sexp) },
+				:ivar => process_block { |processor, sexp| processor.process_ivar(sexp) },
+				:lasgn => process_block { |processor, sexp| processor.process_lasgn(sexp) },
+				:lit => process_block { |processor, sexp| processor.process_lit(sexp) },
+				:lvar => process_block { |processor, sexp| processor.process_lvar(sexp) },
+				:module => process_block { |processor, sexp| processor.process_module(sexp) },
+				:nil => process_block { |processor, sexp| processor.process_nil(sexp) },
+				:op_asgn1 => process_block { |processor, sexp| processor.process_op_asgn1(sexp) },
+				:op_asgn2 => process_block { |processor, sexp| processor.process_op_asgn2(sexp) },
+				:op_asgn_and => process_block { |processor, sexp| processor.process_op_asgn_and(sexp) },
+				:op_asgn_or => process_block { |processor, sexp| processor.process_op_asgn_or(sexp) },
+				:rescue => process_block { |processor, sexp| processor.process_rescue(sexp) },
+				:return => process_block { |processor, sexp| processor.process_return(sexp) },
+				:sclass => process_block { |processor, sexp| processor.process_sclass(sexp) },
+				:self => process_block { |processor, sexp| processor.process_self(sexp) },
+				:str => process_block { |processor, sexp| processor.process_str(sexp) },
+				:super => process_block { |processor, sexp| processor.process_super(sexp) },
+				:true => process_block { |processor, sexp| processor.process_true(sexp) },
+				:until => process_block { |processor, sexp| processor.process_until(sexp) },
+				:while => process_block { |processor, sexp| processor.process_while(sexp) },
+				:yield => process_block { |processor, sexp| processor.process_yield(sexp) },
+			}
+		end
+
+		## Sexp -> String
+		def process(sexp)
+			block = X::BLOCKS[sexp.type]
+			if block.nil?
+				raise ArgumentError, sexp.inspect
+			end
+			return block.call(self, sexp)
+		end
+	end
+end

data/ruby/MetaRuby/Processor/SourceProcessor.rb

@@ -0,0 +1,788 @@
+module MetaRuby
+	## <>
+	##   @depth: int32
+	##   @level: int32
+	class SourceProcessor < Processor
+		## % nojava
+		## <>
+		module X
+			BINARY_L = {
+				"*" => 12.i32, "/" => 12.i32, "%" => 12.i32,
+				"+" => 11.i32, "-" => 11.i32,
+				"<<" => 10.i32, ">>" => 10.i32,
+				"&" => 9.i32,
+				"|" => 8.i32, "^" => 8.i32,
+				"<" => 7.i32, "<=" => 7.i32, ">=" => 7.i32, ">" => 7.i32,
+				"&&" => 5.i32,
+				"||" => 4.i32,
+			}
+
+			BINARY_R = {
+				"**" => 14.i32,
+			}
+
+			BINARY_X = {
+				"==" => 6.i32, "!=" => 6.i32, "=~" => 6.i32, "!~" => 6.i32, "===" => 6.i32, "<=>" => 6.i32,
+				".." => 3.i32, "..." => 3.i32,
+			}
+		end
+
+		# ===
+
+		class << self
+			## Sexp -> String
+			def process(sexp)
+				return INSTANCE.process(sexp)
+			end
+		end
+
+		# ===
+
+		## -> void
+		def initialize
+			super()
+			@depth = 0.i32
+			@level = 0.i32
+			return
+		end
+
+		# ===
+
+		INSTANCE = SourceProcessor.__new__
+
+		# ===
+
+		## -> String
+		def __tabs
+			return "\t" * @depth
+		end
+
+		## java.lang.Object? -> String
+		def __with_depth(o)
+			if o.nil?
+				return ""
+			elsif o.is_a?(Sexp)
+				@depth += 1
+				begin
+					return process(o)
+				ensure
+					@depth -= 1
+				end
+			else
+				raise ArgumentError, o.inspect
+			end
+		end
+
+		## int32, &{-> void} -> void
+		def __with_level(new_level)
+			old_level = @level
+			@level = new_level
+			begin
+				yield
+				return
+			ensure
+				@level = old_level
+			end
+		end
+
+		## int32, &{-> String} -> String
+		def __with_level_s(new_level)
+			old_level = @level
+			@level = new_level
+			begin
+				return yield
+			ensure
+				@level = old_level
+			end
+		end
+
+		## Sexp, int32 -> Sexp
+		def __arglist_sexp(sexp, i)
+			arglist_sexp = Sexp.__new__(:arglist)
+			n = sexp.size_as_int32
+			while i < n
+				e = sexp.fetch_as_sexp(i)
+				if e.type == :arglist
+					arglist_sexp.concat(e.args)
+				else
+					arglist_sexp << e
+				end
+				i += 1
+			end
+			return arglist_sexp
+		end
+
+		## Sexp -> Array<String>
+		def __process_arglist(sexp)
+			a = []
+			__with_level(2.i32) do
+				n = sexp.size_as_int32
+				n.times do |i|
+					arg_sexp = sexp.fetch_as_sexp(i)
+					case arg_sexp.type
+					when :block_pass
+						s = "&" + process(arg_sexp.fetch_as_sexp(0.i32))
+					when :splat
+						s = "*" + process(arg_sexp.fetch_as_sexp(0.i32))
+					else
+						s = process(arg_sexp)
+					end
+					a.push(s)
+				end
+			end
+			return a
+		end
+
+		## Sexp -> Hash<Symbol, Sexp>
+		def __lasgn_hash(sexp)
+			h = {}
+			n = sexp.size_as_int32
+			n.times do |i|
+				lasgn_sexp = sexp.fetch_as_sexp(i)
+				raise ArgumentError if lasgn_sexp.type != :lasgn
+				k = lasgn_sexp.fetch_as_s(0.i32)
+				v = lasgn_sexp.fetch_as_sexp(1.i32)
+				h[k] = v
+			end
+			return h
+		end
+
+		## Sexp -> Array<String>
+		def __process_args(sexp)
+			a = []
+			n = sexp.size_as_int32
+			if n == 0
+				return a
+			end
+			o = sexp.fetch(n - 1)
+			if o.is_a?(Sexp)
+				if o.type == :block
+					h = __lasgn_hash(o)
+					n -= 1
+					n.times do |i|
+						k = sexp.fetch_as_s(i)
+						v = h[k]
+						if v.nil?
+							a.push(k)
+						else
+							s = __with_level_s(2.i32) { process(v) }
+							a.push(k + " = " + s)
+						end
+					end
+					return a
+				end
+			end
+			n.times do |i|
+				o = sexp.fetch(i)
+				case o
+				when String
+					a.push(o.to_s)
+				when Symbol
+					a.push(o.to_s)
+				when Sexp
+					lasgn_sexp = o
+					raise ArgumentError if lasgn_sexp.type != :lasgn
+					k = lasgn_sexp.fetch_as_s(0.i32)
+					v = lasgn_sexp.fetch_as_sexp(1.i32)
+					s = __with_level_s(2.i32) { process(v) }
+					a.push(k + " = " + s)
+				else
+					raise TypeError
+				end
+			end
+			return a
+		end
+
+		## Sexp, int32 -> String
+		def __process_scope(sexp, i)
+			a = []
+			@depth += 1
+			n = sexp.size_as_int32
+			while i < n
+				e = sexp.fetch_as_sexp(i)
+				if e.type == :scope
+					o = e[0.i32]
+					unless o.nil?
+						s = process(o.is_a!(Sexp))
+						a.push(s)
+					end
+				else
+					s = process(e)
+					a.push(s)
+				end
+				i += 1
+			end
+			@depth -= 1
+			return a.join
+		end
+
+		## Sexp -> Array<String>
+		def __process_hash(sexp)
+			a = []
+			__with_level(2.i32) do
+				n = sexp.size_as_int32
+				symbol = true
+				i = 0.i32
+				while i < n
+					key_sexp = sexp.fetch_as_sexp(i)
+					if key_sexp.type != :lit || !key_sexp.fetch(0.i32).is_a?(Symbol)
+						symbol = false
+					end
+					i += 2
+				end
+				i = 0.i32
+				while i < n
+					key_sexp = sexp.fetch_as_sexp(i)
+					i += 1
+					value_sexp = sexp.fetch_as_sexp(i)
+					i += 1
+					if symbol
+						k = key_sexp.fetch_as_s(0.i32)
+						v = process(value_sexp)
+						a.push("#{k}: #{v}")
+					else
+						k = process(key_sexp)
+						v = process(value_sexp)
+						a.push("#{k} => #{v}")
+					end
+				end
+			end
+			return a
+		end
+
+		## java.lang.Object?, Sexp, String, int32 -> String
+		def __unary(o, arglist_sexp, name, new_level)
+			if o.nil?
+				r = "self"
+			else
+				r = __with_level_s(new_level) { process(o.is_a!(Sexp)) }
+			end
+			s = "#{name}#{r}"
+			return @level > new_level ? "(#{s})" : s
+		end
+
+		## java.lang.Object?, Sexp, String, int32, int32, int32 -> String
+		def __binary(o, arglist_sexp, name, new_level, dl, dr)
+			if o.nil?
+				r = "self"
+			else
+				r = __with_level_s(new_level + dl) { process(o.is_a!(Sexp)) }
+			end
+			a = __with_level_s(new_level + dr) { process(arglist_sexp.fetch_as_sexp(0.i32)) }
+			s = "#{r} #{name} #{a}"
+			return @level > new_level ? "(#{s})" : s
+		end
+
+		# ===
+
+		## Sexp -> String
+		def process(sexp)
+			if @level > 0
+				return super(sexp)
+			end
+			if sexp.type == :block
+				a = []
+				n = sexp.size_as_int32
+				n.times do |i|
+					o = sexp.fetch(i)
+					if o.nil?
+						# ...
+					elsif o.is_a?(Sexp)
+						a.push(process(o))
+					else
+						raise ArgumentError, sexp.inspect
+					end
+				end
+				return a.join
+			end
+			s = __tabs + super(sexp) + "\n"
+			comments = sexp.comments
+			if comments.nil?
+				return s
+			end
+			return comments.map { |c| __tabs + c + "\n" }.join + s
+		end
+
+		## Sexp -> String
+		def process_array(sexp)
+			a = __process_arglist(sexp)
+			if @level < 2 && a.size_as_int32 > 0
+				s = a.map { |c| __tabs + "\t" + c + "," + "\n" }.join
+				return "[" + "\n" + s + __tabs + "]"
+			else
+				s = a.join(", ")
+				return "[#{s}]"
+			end
+		end
+
+		## Sexp -> String
+		def process_attrasgn(sexp)
+			raise ArgumentError if @level > 1
+			arglist_sexp = __arglist_sexp(sexp, 2.i32)
+			r = __with_level_s(2.i32) { process(sexp.fetch_as_sexp(0.i32)) }
+			name = sexp.fetch_as_s(1.i32)
+			raise ArgumentError unless name.end_with?("=")
+			name = name.chop
+			if name == "[]"
+				k = __with_level_s(2.i32) { process(arglist_sexp.fetch_as_sexp(0.i32)) }
+				v = __with_level_s(1.i32) { process(arglist_sexp.fetch_as_sexp(1.i32)) }
+				return "#{r}[#{k}] = #{v}"
+			else
+				s = __with_level_s(1.i32) { process(arglist_sexp.fetch_as_sexp(0.i32)) }
+				return "#{r}.#{name} = #{s}"
+			end
+		end
+
+		## Sexp -> String
+		def process_call(sexp)
+			name = sexp.fetch_as_s(1.i32)
+			arglist_sexp = __arglist_sexp(sexp, 2.i32)
+			o = sexp.fetch(0.i32)
+			new_level = X::BINARY_L[name]
+			unless new_level.nil?
+				return __binary(o, arglist_sexp, name, new_level, 0.i32, 1.i32)
+			end
+			new_level = X::BINARY_R[name]
+			unless new_level.nil?
+				return __binary(o, arglist_sexp, name, new_level, 1.i32, 0.i32)
+			end
+			new_level = X::BINARY_X[name]
+			unless new_level.nil?
+				return __binary(o, arglist_sexp, name, new_level, 1.i32, 1.i32)
+			end
+			case name
+			when "[]"
+				if o.nil?
+					r = "self"
+				else
+					r = __with_level_s(15.i32) { process(o.is_a!(Sexp)) }
+				end
+				a = __process_arglist(arglist_sexp)
+				s = a.join(", ")
+				return "#{r}[#{s}]"
+			when "[]="
+				raise ArgumentError if @level > 1
+				if o.nil?
+					r = "self"
+				else
+					r = __with_level_s(15.i32) { process(o.is_a!(Sexp)) }
+				end
+				n = arglist_sexp.size_as_int32
+				if n == 0
+					raise ArgumentError
+				end
+				n -= 1
+				a = []
+				__with_level(2.i32) do
+					n.times do |i|
+						arg_sexp = arglist_sexp.fetch_as_sexp(i)
+						a.push(process(arg_sexp))
+					end
+				end
+				s = a.join(", ")
+				v = __with_level_s(1.i32) { process(arglist_sexp.fetch_as_sexp(n)) }
+				return "#{r}[#{s}] = #{v}"
+			when "!"
+				return __unary(o, arglist_sexp, "!", 13.i32)
+			when "~"
+				return __unary(o, arglist_sexp, "~", 13.i32)
+			when "+@"
+				return __unary(o, arglist_sexp, "+", 13.i32)
+			when "-@"
+				return __unary(o, arglist_sexp, "-", 13.i32)
+			end
+			if o.nil?
+				f = name
+			else
+				r = __with_level_s(15.i32) { process(o.is_a!(Sexp)) }
+				f = r + "." + name
+			end
+			n = arglist_sexp.size_as_int32
+			if n == 0
+				return f
+			end
+			a = __process_arglist(arglist_sexp)
+			s = a.join(", ")
+			return "#{f}(#{s})"
+		end
+
+		## Sexp -> String
+		def process_case(sexp)
+			c = __with_level_s(2.i32) { process(sexp.fetch_as_sexp(0.i32)) }
+			a = []
+			n = sexp.size_as_int32
+			if n == 0
+				raise ArgumentError
+			end
+			n -= 1
+			i = 1.i32
+			while i < n
+				when_sexp = sexp.fetch_as_sexp(i)
+				raise ArgumentError if when_sexp.type != :when
+				array_sexp = when_sexp.fetch_as_sexp(0.i32)
+				raise ArgumentError if array_sexp.type != :array
+				if array_sexp.size_as_int32 != 1
+					raise ArgumentError
+				end
+				w = __with_level_s(2.i32) { process(array_sexp.fetch_as_sexp(0.i32)) }
+				s = __with_depth(when_sexp[1.i32])
+				a.push(__tabs + "when" + " " + w + "\n" + s)
+				i += 1
+			end
+			o = sexp[n]
+			unless o.nil?
+				s = __with_depth(o)
+				a.push(__tabs + "else" + "\n" + s)
+			end
+			return "case" + " " + c + "\n" + a.join + __tabs + "end"
+		end
+
+		## Sexp -> String
+		def process_cdecl(sexp)
+			raise ArgumentError if @level > 1
+			name = sexp.fetch_as_s(0.i32)
+			s = __with_level_s(1.i32) { process(sexp.fetch_as_sexp(1.i32)) }
+			return "#{name} = #{s}"
+		end
+
+		## Sexp -> String
+		def process_class(sexp)
+			raise ArgumentError if @level > 0
+			name = sexp.fetch_as_s(0.i32)
+			s = __process_scope(sexp, 2.i32)
+			o = sexp[1.i32]
+			if o.nil?
+				return "class" + " " + name + "\n" + s + __tabs + "end"
+			else
+				c = __with_level_s(2.i32) { process(o.is_a!(Sexp)) }
+				return "class" + " " + name + " < " + c + "\n" + s + __tabs + "end"
+			end
+		end
+
+		## Sexp -> String
+		def process_colon2(sexp)
+			name = sexp.fetch_as_s(1.i32)
+			s = __with_level_s(16.i32) { process(sexp.fetch_as_sexp(0.i32)) }
+			return "#{s}::#{name}"
+		end
+
+		## Sexp -> String
+		def process_colon3(sexp)
+			name = sexp.fetch_as_s(0.i32)
+			return "::#{name}"
+		end
+
+		## Sexp -> String
+		def process_const(sexp)
+			name = sexp.fetch_as_s(0.i32)
+			return name
+		end
+
+		## Sexp -> String
+		def process_defn(sexp)
+			raise ArgumentError if @level > 0
+			name = sexp.fetch_as_s(0.i32)
+			s = __process_scope(sexp, 2.i32)
+			args_sexp = sexp.fetch_as_sexp(1.i32)
+			raise ArgumentError if args_sexp.type != :args
+			a = __process_args(args_sexp)
+			if a.empty?
+				return "def" + " " + name + "\n" + s + __tabs + "end"
+			end
+			t = a.join(", ")
+			return "def" + " " + name + "(" + t + ")" + "\n" + s + __tabs + "end"
+		end
+
+		## Sexp -> String
+		def process_ensure(sexp)
+			s0 = __with_depth(sexp[0.i32])
+			s1 = __with_depth(sexp[1.i32])
+			return "begin" + "\n" + s0 + __tabs + "ensure" + "\n" + s1 + __tabs + "end"
+		end
+
+		## Sexp -> String
+		def process_false(sexp)
+			return "false"
+		end
+
+		## Sexp -> String
+		def process_hash(sexp)
+			a = __process_hash(sexp)
+			if @level < 2 && a.size_as_int32 > 0
+				s = a.map { |c| __tabs + "\t" + c + "," + "\n" }.join
+				return "{" + "\n" + s + __tabs + "}"
+			else
+				s = a.join(", ")
+				return "{#{s}}"
+			end
+		end
+
+		## Sexp -> String
+		def process_iasgn(sexp)
+			raise ArgumentError if @level > 1
+			name = sexp.fetch_as_s(0.i32)
+			s = __with_level_s(1.i32) { process(sexp.fetch_as_sexp(1.i32)) }
+			return "#{name} = #{s}"
+		end
+
+		## Sexp -> String
+		def process_if(sexp)
+			then_o = sexp[1.i32]
+			else_o = sexp[2.i32]
+			if @level == 0
+				c = __with_level_s(2.i32) { process(sexp.fetch_as_sexp(0.i32)) }
+				if then_o.nil? && else_o.nil?
+					raise ArgumentError
+				end
+				if then_o.nil?
+					s1 = __with_depth(else_o)
+					return "unless" + " " + c + "\n" + s1 + __tabs + "end"
+				end
+				if else_o.nil?
+					s0 = __with_depth(then_o)
+					return "if" + " " + c + "\n" + s0 + __tabs + "end"
+				end
+				s0 = __with_depth(then_o)
+				else_sexp = else_o.is_a!(Sexp)
+				if else_sexp.type == :if
+					if else_sexp[1.i32].not_nil?
+						s1 = process_if(else_sexp)
+						return "if" + " " + c + "\n" + s0 + __tabs + "els" + s1
+					end
+				end
+				s1 = __with_depth(else_o)
+				return "if" + " " + c + "\n" + s0 + __tabs + "else" + "\n" + s1 + __tabs + "end"
+			else
+				c = __with_level_s(3.i32) { process(sexp.fetch_as_sexp(0.i32)) }
+				s0 = __with_level_s(2.i32) { process(then_o.is_a!(Sexp)) }
+				s1 = __with_level_s(2.i32) { process(else_o.is_a!(Sexp)) }
+				s = c + " " + "?" + " " + s0 + " " + ":" + " " + s1
+				return @level > 2 ? "(#{s})" : s
+			end
+		end
+
+		## Sexp -> String
+		def process_iter(sexp)
+			c = __with_level_s(2.i32) { process(sexp.fetch_as_sexp(0.i32)) }
+			s = __with_depth(sexp[2.i32])
+			o = sexp.fetch(1.i32)
+			if o.nil?
+				return c + " " + "{" + "\n" + s + __tabs + "}"
+			else
+				args_sexp = o.is_a!(Sexp)
+				case args_sexp.type
+				when :args
+					a = __process_args(args_sexp)
+					if a.empty?
+						return c + " " + "{" + "\n" + s + __tabs + "}"
+					end
+				when :lasgn
+					a = []
+					name = args_sexp.fetch_as_s(0.i32)
+					a.push(name)
+				when :masgn
+					a = []
+					array_sexp = args_sexp.fetch_as_sexp(0.i32)
+					raise ArgumentError if array_sexp.type != :array
+					n = array_sexp.size_as_int32
+					n.times do |i|
+						name = array_sexp.fetch_as_sexp(i).fetch_as_s(0.i32)
+						a.push(name)
+					end
+				else
+					raise ArgumentError
+				end
+				t = a.join(", ")
+				return c + " " + "{" + " " + "|#{t}|" + "\n" + s + __tabs + "}"
+			end
+		end
+
+		## Sexp -> String
+		def process_ivar(sexp)
+			name = sexp.fetch_as_s(0.i32)
+			return name
+		end
+
+		## Sexp -> String
+		def process_lasgn(sexp)
+			raise ArgumentError if @level > 1
+			name = sexp.fetch_as_s(0.i32)
+			arg_sexp = sexp.fetch_as_sexp(1.i32)
+			s = __with_level_s(1.i32) { process(arg_sexp) }
+			return "#{name} = #{s}"
+		end
+
+		## Sexp -> String
+		def process_lit(sexp)
+			return sexp.fetch(0.i32).inspect
+		end
+
+		## Sexp -> String
+		def process_lvar(sexp)
+			name = sexp.fetch_as_s(0.i32)
+			return name
+		end
+
+		## Sexp -> String
+		def process_module(sexp)
+			raise ArgumentError if @level > 0
+			name = sexp.fetch_as_s(0.i32)
+			s = __process_scope(sexp, 1.i32)
+			return "module" + " " + name + "\n" + s + __tabs + "end"
+		end
+
+		## Sexp -> String
+		def process_nil(sexp)
+			return "nil"
+		end
+
+		## Sexp -> String
+		def process_op_asgn1(sexp)
+			raise ArgumentError if @level > 1
+			r = __with_level_s(2.i32) { process(sexp.fetch_as_sexp(0.i32)) }
+			arg_sexp = sexp.fetch_as_sexp(1.i32)
+			if arg_sexp.type == :arglist
+				a = __process_arglist(arg_sexp)
+				t = a.join(", ")
+			else
+				t = __with_level_s(2.i32) { process(arg_sexp) }
+			end
+			operator = sexp.fetch_as_s(2.i32)
+			s = __with_level_s(1.i32) { process(sexp.fetch_as_sexp(3.i32)) }
+			return "#{r}[#{t}] #{operator}= #{s}"
+		end
+
+		## Sexp -> String
+		def process_op_asgn2(sexp)
+			raise ArgumentError if @level > 1
+			r = __with_level_s(2.i32) { process(sexp.fetch_as_sexp(0.i32)) }
+			name = sexp.fetch_as_s(1.i32)
+			raise ArgumentError unless name.end_with?("=")
+			name = name.chop
+			operator = sexp.fetch_as_s(2.i32)
+			s = __with_level_s(1.i32) { process(sexp.fetch_as_sexp(3.i32)) }
+			return "#{r}.#{name} #{operator}= #{s}"
+		end
+
+		## Sexp -> String
+		def process_op_asgn_and(sexp)
+			raise ArgumentError if @level > 1
+			lasgn_sexp = sexp.fetch_as_sexp(1.i32)
+			raise ArgumentError if lasgn_sexp.type != :lasgn
+			name = lasgn_sexp.fetch_as_s(0.i32)
+			v = __with_level_s(1.i32) { process(lasgn_sexp.fetch_as_sexp(1.i32)) }
+			return "#{name} &&= #{v}"
+		end
+
+		## Sexp -> String
+		def process_op_asgn_or(sexp)
+			raise ArgumentError if @level > 1
+			lasgn_sexp = sexp.fetch_as_sexp(1.i32)
+			raise ArgumentError if lasgn_sexp.type != :lasgn
+			name = lasgn_sexp.fetch_as_s(0.i32)
+			v = __with_level_s(1.i32) { process(lasgn_sexp.fetch_as_sexp(1.i32)) }
+			return "#{name} ||= #{v}"
+		end
+
+		## Sexp -> String
+		def process_rescue(sexp)
+			raise ArgumentError if @level > 0
+			n = sexp.size_as_int32
+			a = []
+			i = 1.i32
+			while i < n
+				resbody_sexp = sexp.fetch_as_sexp(i)
+				raise ArgumentError if resbody_sexp.type != :resbody
+				array_sexp = resbody_sexp.fetch_as_sexp(0.i32)
+				raise ArgumentError if array_sexp.type != :array
+				if array_sexp.size_as_int32 != 1
+					raise ArgumentError
+				end
+				r = __with_level_s(2.i32) { process(array_sexp.fetch_as_sexp(0.i32)) }
+				s = __with_depth(resbody_sexp[1.i32])
+				a.push(__tabs + "rescue" + " " + r + "\n" + s)
+				i += 1
+			end
+			s = __with_depth(sexp[0.i32])
+			return "begin" + "\n" + s + a.join + __tabs + "end"
+		end
+
+		## Sexp -> String
+		def process_return(sexp)
+			raise ArgumentError if @level > 0
+			case sexp.size_as_int32
+			when 0.i32
+				return "return"
+			when 1.i32
+				s = __with_level_s(1.i32) { process(sexp.fetch_as_sexp(0.i32)) }
+				return "return" + " " + s
+			else
+				raise ArgumentError
+			end
+		end
+
+		## Sexp -> String
+		def process_sclass(sexp)
+			raise ArgumentError if @level > 0
+			c = __with_level_s(2.i32) { process(sexp.fetch_as_sexp(0.i32)) }
+			s = __process_scope(sexp, 1.i32)
+			return "class" + " << " + c + "\n" + s + __tabs + "end"
+		end
+
+		## Sexp -> String
+		def process_self(sexp)
+			return "self"
+		end
+
+		## Sexp -> String
+		def process_str(sexp)
+			return sexp.fetch(0.i32).is_a!(String).inspect
+		end
+
+		## Sexp -> String
+		def process_super(sexp)
+			a = __process_arglist(sexp)
+			s = a.join(", ")
+			return "super" + "(#{s})"
+		end
+
+		## Sexp -> String
+		def process_true(sexp)
+			return "true"
+		end
+
+		## Sexp -> String
+		def process_until(sexp)
+			raise ArgumentError if @level > 0
+			c = __with_level_s(2.i32) { process(sexp.fetch_as_sexp(0.i32)) }
+			s = __with_depth(sexp[1.i32])
+			if sexp.fetch(2.i32)
+				return "until" + " " + c + "\n" + s + __tabs + "end"
+			else
+				return "begin" + "\n" + s + __tabs + "end" + " " + "until" + " " + c
+			end
+		end
+
+		## Sexp -> String
+		def process_while(sexp)
+			raise ArgumentError if @level > 0
+			c = __with_level_s(2.i32) { process(sexp.fetch_as_sexp(0.i32)) }
+			s = __with_depth(sexp[1.i32])
+			if sexp.fetch(2.i32)
+				return "while" + " " + c + "\n" + s + __tabs + "end"
+			else
+				return "begin" + "\n" + s + __tabs + "end" + " " + "while" + " " + c
+			end
+		end
+
+		## Sexp -> String
+		def process_yield(sexp)
+			a = __process_arglist(sexp)
+			if a.empty?
+				return "yield"
+			end
+			s = a.join(", ")
+			return "yield" + "(#{s})"
+		end
+	end
+end

data/ruby/MetaRuby/Sexp.rb

@@ -0,0 +1,50 @@
+module MetaRuby
+	## <>
+	##   @__comments: Array<String>?
+	class Sexp < ::Sexp
+		## Symbol -> void
+		## Symbol, Array<java.lang.Object?> -> void
+		def initialize(type, args = nix)
+			if args.nix?
+				super(type)
+			else
+				super(type, args)
+			end
+			@__comments = nil
+			return
+		end
+
+		# ===
+
+		## int32 -> String
+		## Fixnum -> String
+		def fetch_as_s(i)
+			o = fetch(i)
+			case o
+			when String
+				return o
+			when Symbol
+				return o.to_s
+			else
+				raise TypeError
+			end
+		end
+
+		## int32 -> Sexp
+		## Fixnum -> Sexp
+		def fetch_as_sexp(i)
+			return fetch(i).is_a!(Sexp)
+		end
+
+		## -> Array<String>?
+		def comments
+			return @__comments
+		end
+
+		## Array<String>? -> void
+		def comments=(o)
+			@__comments = o
+			return
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require "meta-ruby"

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: meta-ruby
+version: !ruby/object:Gem::Version
+  version: 3.1.0
+platform: ruby
+authors:
+- InfraRuby Vision
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: infraruby-shim
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: s-expression
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: fab
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: infraruby-task
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Ruby metaprogramming with s-expressions
+email: rubygems@infraruby.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- bin/meta-hello
+- lib/meta-ruby.rb
+- meta-ruby.gemspec
+- pool/meta-ruby.cut
+- pool/meta-ruby.jar
+- ruby/MetaRuby.rb
+- ruby/MetaRuby/Directory.rb
+- ruby/MetaRuby/Generator.rb
+- ruby/MetaRuby/Processor.rb
+- ruby/MetaRuby/Processor/SourceProcessor.rb
+- ruby/MetaRuby/Sexp.rb
+- spec/spec_helper.rb
+homepage: http://infraruby.com/
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby metaprogramming with s-expressions
+test_files: []