msgpack-idl 0.1.0

data/lib/msgpack/idl/parser/transform.rb

@@ -0,0 +1,260 @@
+#
+# MessagePack IDL Processor
+#
+# Copyright (C) 2011 FURUHASHI Sadayuki
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module MessagePack
+module IDL
+
+
+class ParsletTransform < Parslet::Transform
+	rule(:sequence_x => simple(:x)) {
+		x
+	}
+
+	rule(:sequence_xs => simple(:xs)) {
+		xs
+	}
+
+	rule(:sequence => simple(:x)) {
+		x ? AST::Sequence.new([x]) : AST::Sequence.new
+	}
+
+	rule(:sequence => sequence(:x)) {
+		AST::Sequence.new(x)
+	}
+
+
+	rule(:val_int => simple(:i)) {
+		i.to_i
+	}
+
+	rule(:val_optional => simple(:x)) {
+		AST::FIELD_OPTIONAL
+	}
+
+	rule(:val_required => simple(:x)) {
+		AST::FIELD_REQUIRED
+	}
+
+	rule(:val_override => simple(:x)) {
+		AST::FUNC_OVERRIDE
+	}
+
+	rule(:val_remove => simple(:x)) {
+		AST::FUNC_REMOVE
+	}
+
+	rule(:val_add => simple(:x)) {
+		AST::FUNC_ADD
+	}
+
+
+	rule(:name => simple(:n)) {
+		n.to_s
+	}
+
+
+	rule(:field_id => simple(:i),
+			 :field_modifier => simple(:m),
+			 :field_type => simple(:t),
+			 :field_name => simple(:n),
+			 :field_value => simple(:v)) {
+		m = m() ? m() : AST::FIELD_REQUIRED
+		if v == nil
+			AST::Field.new(i, t, m, n)
+		else
+			AST::ValueAssignedField.new(i, t, m, n, v)
+		end
+	}
+
+	rule(:generic_type => simple(:n),
+			 :type_params => simple(:tp)) {
+		if tp
+			AST::GenericType.new(n, tp)
+		else
+			AST::Type.new(n)
+		end
+	}
+
+	rule(:field_type => simple(:t),
+			 :field_type_maybe => simple(:n)) {
+		nullable = !!n
+		if t.is_a?(AST::GenericType)
+			AST::GenericType.new(t.name, t.type_params, nullable)
+		else
+			AST::Type.new(t.name, nullable)
+		end
+	}
+
+
+	rule(:message_name => simple(:n),
+			 :message_body => sequence(:b),
+			 :super_class => simple(:sc)) {
+		AST::Message.new(n, sc, b)
+	}
+
+	rule(:exception_name => simple(:n),
+			 :exception_body => sequence(:b),
+			 :super_class => simple(:sc)) {
+		AST::Exception.new(n, sc, b)
+	}
+
+
+	rule(:enum_field_id => simple(:i),
+			 :enum_field_name => simple(:n)) {
+		AST::EnumField.new(i, n)
+	}
+
+	rule(:enum_name => simple(:n),
+			 :enum_body => sequence(:b)) {
+		AST::Enum.new(n, b)
+	}
+
+
+	rule(:return_type => simple(:rt),
+			 :func_name => simple(:n),
+			 :func_args => simple(:a),
+			 :func_throws => simple(:ex)) {
+		AST::Func.new(n, rt, a, ex)
+	}
+
+	rule(:service_description => sequence(:s)) {
+		current = AST::ServiceVersion.new(0, [])
+		versions = [current]
+		s.each {|l|
+			case l
+			when Integer
+				v = versions.find {|v| v.version == l }
+				if v
+					current = v
+				else
+					current = AST::ServiceVersion.new(l, [])
+					versions << current
+				end
+			else
+				current.funcs << l
+			end
+		}
+		versions
+	}
+
+	rule(:service_name => simple(:n),
+			 :service_version => simple(:v),
+			 :service_funcs => sequence(:fs)) {
+		AST::Service.new(n, v, fs)
+	}
+
+
+	rule(:scope_service => simple(:s),
+			 :scope_service_version => simple(:v),
+			 :scope_name => simple(:n),
+			 :scope_default => simple(:d)) {
+		if d
+			AST::Scope.new(s, v, n, true)
+		else
+			AST::Scope.new(s, v, n, false)
+		end
+	}
+
+	rule(:application_name => simple(:n),
+			 :application_body => sequence(:b)) {
+		AST::Application.new(n, b)
+	}
+
+
+	rule(:namespace_name => simple(:n)) {
+		AST::Namespace.new(n, nil)
+	}
+
+	rule(:namespace_name => simple(:n),
+			 :namespace_lang => simple(:l)) {
+		AST::Namespace.new(n, l)
+	}
+
+
+	rule(:path => simple(:n)) {
+		n
+	}
+
+	rule(:include => simple(:n)) {
+		AST::Include.new(n.to_s)
+	}
+
+
+	rule(:document => sequence(:es)) {
+		AST::Document.new(es)
+	}
+
+
+	rule(:literal_const => simple(:n)) {
+		AST::ConstLiteral.new(n)
+	}
+
+	rule(:literal_enum_name => simple(:n),
+			 :literal_enum_field => simple(:f)) {
+		AST::EnumLiteral.new(n, f)
+	}
+
+	rule(:literal_int => simple(:i)) {
+		AST::IntLiteral.new(i.to_i)
+	}
+
+	rule(:literal_float => simple(:f)) {
+		AST::FloatLiteral.new(f.to_f)
+	}
+
+	rule(:literal_str_dq => simple(:s)) {
+		s.to_s.gsub(/\\(.)/) {|e|
+			eval("\"\\#{$~[1]}\"")  # TODO escape
+		}
+	}
+
+	rule(:literal_str_sq => simple(:s)) {
+		s.to_s
+	}
+
+	rule(:literal_str_seq => sequence(:ss)) {
+		AST::StringLiteral.new(ss.join)
+	}
+
+	rule(:literal_nil => simple(:_)) {
+		AST::NilLiteral.new
+	}
+
+	rule(:literal_true => simple(:_)) {
+		AST::TrueLiteral.new
+	}
+
+	rule(:literal_false => simple(:_)) {
+		AST::FalseLiteral.new
+	}
+
+	#rule(:literal_list => simple(:a)) {
+	#	AST::ListLiteral.new(Array.new(a))
+	#}
+
+	#rule(:literal_map => simple(:ps)) {
+	#	AST::MapLiteral.new(Array.new(ps))
+	#}
+
+	#rule(:literal_map_key => simple(:k), :literal_map_value => simple(:v)) {
+	#	AST::MapLiteralPair.new(k, v)
+	#}
+end
+
+
+end
+end

data/lib/msgpack/idl/parser.rb

@@ -0,0 +1,84 @@
+#
+# MessagePack IDL Processor
+#
+# Copyright (C) 2011 FURUHASHI Sadayuki
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module MessagePack
+module IDL
+
+
+class Parser
+	include ProcessorModule
+
+	require 'stringio'
+
+	def initialize(search_paths = [])
+		@search_paths = search_paths
+		@parslet = ParsletParser.new
+		@transform = ParsletTransform.new
+		@ast = []
+	end
+
+	attr_reader :ast
+
+	def parse(src, fname, dir)
+		begin
+			tree = @parslet.parse(src)
+			ast = @transform.apply(tree)
+		rescue Parslet::ParseFailed => error
+			msg = @parslet.print_error(error, fname, StringIO.new).string
+			raise SyntaxError, msg
+		end
+		ast.each {|e|
+			if e.class == AST::Include
+				parse_include(e.path, dir, fname)
+			else
+				@ast << e
+			end
+		}
+		self
+	end
+
+	def parse_file(path)
+		parse(File.read(path), File.basename(path), File.dirname(path))
+	end
+
+	protected
+	def parse_include(inc, dir, fname)
+		if dir
+			search_paths = @search_paths + [File.expand_path(dir)]
+		else
+			search_paths = @search_paths
+		end
+		search_paths.each {|dir|
+			real_path = File.join(dir, inc)
+			if File.file?(real_path)
+				return parse_file(real_path)
+			end
+		}
+		raise IncludeError, format_include_error(inc, fname)
+	end
+
+	def format_include_error(inc, fname)
+		[
+			"#{fname}:",
+			"  Can't include file #{inc}"
+		].join("\n")
+	end
+end
+
+
+end
+end

data/lib/msgpack/idl/version.rb

@@ -0,0 +1,7 @@
+module MessagePack
+module IDL
+
+VERSION = '0.1.0'
+
+end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: msgpack-idl
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- FURUHASHI Sadayuki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-23 00:00:00 +09:00
+default_executable: msgpack-idl
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: parslet
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: 
+email: frsyuki@users.sourceforge.jp
+executables: 
+- msgpack-idl
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- AUTHORS
+- ChangeLog
+- README
+- lib/msgpack/idl/ast.rb
+- lib/msgpack/idl/command/example.rb
+- lib/msgpack/idl/command/idl.rb
+- lib/msgpack/idl/error.rb
+- lib/msgpack/idl/evaluator.rb
+- lib/msgpack/idl/generator.rb
+- lib/msgpack/idl/ir.rb
+- lib/msgpack/idl/module.rb
+- lib/msgpack/idl/parser.rb
+- lib/msgpack/idl/parser/rule.rb
+- lib/msgpack/idl/parser/transform.rb
+- lib/msgpack/idl/version.rb
+- bin/msgpack-idl
+has_rdoc: true
+homepage: http://msgpack.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: msgpack
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: MessagePack IDL Processor
+test_files: []
+