msgpack-idl 0.1.0

data/AUTHORS

@@ -0,0 +1 @@
+FURUHASHI Sadayuki <frsyuki _at_ users.sourceforge.jp>

data/ChangeLog

@@ -0,0 +1,5 @@
+
+2011-04-23 version 0.1.0
+
+  * Initial release
+

data/README

@@ -0,0 +1,22 @@
+
+= MessagePack IDL
+
+== Description
+
+== Installation
+
+=== Archive Installation
+
+  rake
+  gem install pkg/msgpack-idl-*
+
+=== Gem Installation
+
+  gem install msgpack-idl
+
+== Copyright
+
+Author::    frsyuki <frsyuki@users.sourceforge.jp>
+Copyright:: Copyright (c) 2011 FURUHASHI Sadayuki
+License::   Apache License, Version 2.0
+

data/bin/msgpack-idl

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+require 'msgpack/idl/command/idl'

data/lib/msgpack/idl/ast.rb

@@ -0,0 +1,251 @@
+#
+# 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
+
+
+module AST
+	class Element
+	end
+
+	class Document < Array
+	end
+
+	class Include
+		def initialize(path)
+			@path = path
+		end
+		attr_reader :path
+	end
+
+
+	class Namespace < Element
+		def initialize(scopes, lang=nil)
+			@scopes = scopes
+			@lang = lang
+		end
+		attr_reader :scopes, :lang
+	end
+
+
+	class Message < Element
+		def initialize(name, super_class, fields)
+			@name = name
+			@super_class = super_class
+			@fields = fields
+		end
+		attr_reader :name, :super_class, :fields
+	end
+
+
+	class Exception < Message
+	end
+
+
+	class Field < Element
+		def initialize(id, type, modifier, name)
+			@id = id
+			@type = type
+			@name = name
+			@modifier = modifier
+		end
+		attr_reader :id, :type, :name, :modifier
+	end
+
+	class ValueAssignedField < Field
+		def initialize(id, type, modifier, name, value)
+			super(id, type, modifier, name)
+			@value = value
+		end
+		attr_reader :value
+	end
+
+
+	class Enum < Element
+		def initialize(name, fields)
+			@name = name
+			@fields = fields
+		end
+		attr_reader :name, :fields
+	end
+
+	class EnumField < Element
+		def initialize(id, name)
+			@id = id
+			@name = name
+		end
+		attr_reader :id, :name
+	end
+
+
+	class Service < Element
+		def initialize(name, version, funcs)
+			@name = name
+			@version = version
+			@funcs = funcs
+		end
+		attr_reader :name, :version, :funcs
+	end
+
+	class Func < Element
+		def initialize(name, return_type, args, exceptions)
+			@name = name
+			@return_type = return_type
+			@args = args
+			@exceptions = exceptions
+		end
+		attr_reader :name, :return_type, :args, :exceptions
+	end
+
+
+	class Application < Element
+		def initialize(name, scopes)
+			@name = name
+			@scopes = scopes
+		end
+
+		attr_reader :name
+		attr_reader :scopes
+	end
+
+	class Scope < Element
+		def initialize(service, version, name, default)
+			@service = service
+			@version = version
+			@name = name
+			@default = default
+		end
+		attr_reader :service, :version, :name, :default
+
+		def default?
+			@default
+		end
+	end
+
+
+	class Type < Element
+		def initialize(name, nullable=false)
+			@name = name
+			@nullable = nullable
+		end
+		attr_reader :name, :nullable
+
+		def nullable?
+			@nullable
+		end
+	end
+
+	class GenericType < Type
+		def initialize(name, type_params, nullable=false)
+			super(name, nullable)
+			@type_params = type_params
+		end
+		attr_reader :type_params
+	end
+
+	FIELD_OPTIONAL = :optional
+	FIELD_REQUIRED = :required
+
+
+	class Literal
+	end
+
+	class ConstLiteral < Literal
+		def initialize(name)
+			@name = name
+		end
+		attr_reader :name
+	end
+
+	class EnumLiteral < Literal
+		def initialize(name, field)
+			@name = name
+			@field = field
+		end
+		attr_reader :name, :field
+	end
+
+	class IntLiteral < Literal
+		def initialize(value)
+			@value = value
+		end
+		attr_reader :value
+	end
+
+	class FlaotLiteral < Literal
+		def initialize(value)
+			@value = value
+		end
+		attr_reader :value
+	end
+
+	class NilLiteral < Literal
+	end
+
+	class BoolLiteral < Literal
+		def initialize(value)
+			@value = value
+		end
+		attr_reader :value
+	end
+
+	class TrueLiteral < BoolLiteral
+		def initialize
+			super(true)
+		end
+	end
+
+	class FalseLiteral < BoolLiteral
+		def initialize
+			super(false)
+		end
+	end
+
+	class StringLiteral < Literal
+		def initialize(value)
+			@value = value
+		end
+	end
+
+	#class ListLiteral < Literal
+	#	def initialize(array)
+	#		@array = array
+	#	end
+	#end
+
+	#class MapLiteralPair
+	#	def initialize(k, v)
+	#		@key = k
+	#		@value = v
+	#	end
+	#end
+
+	#class MapLiteral < Literal
+	#	def initialize(pairs)
+	#		@pairs = pairs
+	#	end
+	#end
+
+
+	class Sequence < Array
+	end
+end
+
+
+end
+end

data/lib/msgpack/idl/command/example.rb

@@ -0,0 +1,135 @@
+#
+# 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 Example
+	LIST = []
+
+	def self.list
+		LIST
+	end
+
+	def self.show(name)
+		n, summary, code = LIST.find {|n, summary, code|
+			name == n
+		}
+		unless code
+			raise "unknown example name: #{name}"
+		end
+		puts "# #{name} - #{summary} example"
+		puts code
+		nil
+	end
+
+	def self.add(name, summary, code)
+		LIST << [name, summary, code]
+	end
+
+	add 'syntax', 'basic syntax', <<EOF
+
+# this is a comment
+// this is a comment
+
+/*
+this is also a comment
+*/
+
+# namespace declaration
+#   java: this becomes the package name
+namespace com.example
+
+# message type declaration
+message MessageName {
+    # <id>: ["optional"] <type> <name> [= <initial value>]
+    1: map<string,string> property
+    2: optional string name
+}
+
+# include other files
+include sample.msgspec
+EOF
+
+	add 'types', 'basic types', <<EOF
+namespace com.example
+
+message BasicTypeExample {
+    1:  byte   f1    # signed 8-bit integer
+    2:  short  f2    # signed 16-bit integer
+    3:  int    f3    # signed 32-bit integer
+    4:  long   f4    # signed 64-bit integer
+    5:  ubyte  f5    # unsigned 8-bit integer
+    6:  ushort f6    # unsigned 16-bit integer
+    7:  uint   f7    # unsigned 32-bit integer
+    8:  ulong  f8    # unsigned 64-bit integer
+    9:  float  f9    # single precision float
+    10: double f10   # double precision float
+    11: bool   f11   # boolean
+    12: raw    f12   # raw bytes
+    13: string f13   # string
+}
+
+message ContainerTypeExample {
+    1: list<string> f1                # list
+    2: map<string,int> f2             # map
+    2: map<string, list<string>> f2   # nesting is ok
+}
+EOF
+
+	add 'optional', 'optional fields', <<EOF
+namespace com.example
+
+message OptionalExample {
+    1: int f1              # required field
+    2: required int f1     # required field
+    3: optional int f2     # optional field
+
+    4: int? f1             # required nullable field
+    5: required int? f1    # required nullable field
+    6: optional int? f2    # optional nullable field
+}
+EOF
+
+	add 'enum', 'enum definition', <<EOF
+enum EnumExcample {
+    0: RED
+    1: GREEN
+    2: BLUE
+}
+EOF
+
+	add 'sample', 'simple sample', <<EOF
+namespace com.example
+
+message UserInfo {
+    1: int uid
+    2: string name
+    3: optional int flags = 1
+}
+
+enum Sites {
+    0: SiteA
+    1: SiteB
+    2: SiteC
+}
+
+message LogInLog {
+    1: UserInfo user
+    2: Sites site
+}
+EOF
+
+end
+

data/lib/msgpack/idl/command/idl.rb

@@ -0,0 +1,262 @@
+#
+# 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.
+#
+require 'optparse'
+
+op = OptionParser.new
+
+prog = File.basename($0)
+op.banner = <<EOF
+Usage: #{prog} [options] -g LANG files...
+       #{prog} --list
+       #{prog} --example [NAME]
+       #{prog} --update LANG [or 'self']
+
+options:
+EOF
+
+comment = <<EOF
+examples:
+  - generate java code from test.msgspec file:
+      $ #{prog} -g java test.msgspec
+      $ ls gen-java  # generated codes are here
+
+  - generate java code from test.msgspec file to ./out directory:
+      $ #{prog} -g java -o out test.msgspec
+
+  - install or update language module
+      $ msgpack-idl --update java
+
+  - show examples
+      $ msgpack-idl --example # show list of examples
+      $ msgpack-idl --example "types"
+
+  - generate sample code
+      $ msgpack-idl --update java
+      $ msgpack-idl --example sample > sample.msgspec
+      $ msgpack-idl -g java sample.msgspec
+EOF
+
+(class<<self;self;end).module_eval do
+	define_method(:usage) do |msg|
+		puts op.to_s
+		puts ""
+		puts comment
+		puts ""
+		puts "error: #{msg}" if msg
+		exit 1
+	end
+end
+
+cmd = :generate
+conf = {
+	:lang => nil,
+	:out => nil,
+	:show_ast => nil,
+	:show_ir => nil,
+}
+
+op.on('--example', 'show IDL examples') {
+	cmd = :example
+}
+
+op.on('--install', 'install or update a language module') {
+	cmd = :update
+}
+
+op.on('--update', 'install or update a language module') {
+	cmd = :update
+}
+
+op.on('--list', 'show list of available language modules') {
+	cmd = :list
+}
+
+op.on_tail('--help', 'show this message') {
+	usage nil
+}
+
+op.on_tail('--version', 'show version') {
+	require 'msgpack/idl/version'
+	puts MessagePack::IDL::VERSION
+	exit 0
+}
+
+op.on('-g', '--lang LANG', 'output language') {|s|
+	conf[:lang] = s
+}
+
+op.on('-o', '--output DIR', 'output directory (default: ./gen-LANG)') {|s|
+	conf[:out] = s
+}
+
+op.on('--show-ast', 'show AST for debugging') {
+	conf[:show_ast] = true
+}
+
+op.on('--show-ir', 'show IR for debugging') {
+	conf[:show_ir] = true
+}
+
+begin
+	op.parse!(ARGV)
+rescue
+	usage $!.to_s
+end
+
+case cmd
+when :example
+	require 'msgpack/idl/command/example'
+
+	def show_available_examples
+		puts "available examples:"
+		Example.list.each {|name,summary,code|
+			puts "  #{name}#{" "*(10-name.length)}: #{summary}"
+		}
+	end
+
+	if ARGV.length == 0
+		show_available_examples
+		exit 1
+	elsif ARGV.length > 1
+		usage "unknown option: #{ARGV[1]}"
+		exit 1
+	end
+
+	name = ARGV[0]
+	begin
+		Example.show(name)
+	rescue
+		show_available_examples
+		puts ""
+		puts "error: unknown example name: #{name.dump}"
+		exit 1
+	end
+
+when :update
+	require 'rubygems'
+	require 'rubygems/gem_runner'
+	require 'rubygems/exceptions'
+
+	if ARGV.length == 0
+		usage "language name or 'self' is required."
+		exit 1
+	elsif ARGV.length > 1
+		usage "unknown option: #{ARGV[1]}"
+		exit 1
+	end
+
+	name = ARGV[0]
+	if name == 'self'
+		pkg = "msgpack-idl"
+	else
+		pkg = "msgpack-idl-#{name}"
+	end
+
+	args = ["install", pkg]
+	puts "installing #{pkg}..."
+
+	begin
+	  Gem::GemRunner.new.run args
+	rescue Gem::SystemExitException => e
+	  exit e.exit_code
+	end
+
+when :list
+	list = []
+	dirs = Gem.all_load_paths.grep("msgpack-idl")
+	dirs.each {|dir|
+		path = File.join(dir, "msgpack/idl/lang")
+		if File.directory?(path)
+			list.concat Dir.entries(path)
+		end
+	}
+
+	puts "available language modules:"
+	list.each {|lang|
+		puts "  #{lang}"
+	}
+
+when :generate
+	if ARGV.length == 0
+		usage nil
+	end
+	unless conf[:lang]
+		usage "-g option is required."
+	end
+
+	lang = conf[:lang]
+	out = conf[:out] || "gen-#{lang}"
+	files = ARGV
+
+	require 'parslet'
+	require 'msgpack/idl/version'
+	require 'msgpack/idl/module'
+	require 'msgpack/idl/error'
+	require 'msgpack/idl/ast'
+	require 'msgpack/idl/ir'
+	require 'msgpack/idl/parser/rule'
+	require 'msgpack/idl/parser/transform'
+	require 'msgpack/idl/parser'
+	require 'msgpack/idl/evaluator'
+	require 'msgpack/idl/generator'
+
+	begin
+		require "msgpack/idl/lang/#{lang}"
+		available = true
+	rescue LoadError
+		available = false
+	end
+	if !available || !MessagePack::IDL::Generator.available?(lang)
+		puts "Language module #{lang.dump} is not available."
+		puts "Try to install it as follows:"
+		puts "  $ #{prog} --install #{lang}"
+		exit 1
+	end
+
+	parser = MessagePack::IDL::Parser.new
+	files.each {|path|
+		if path == "-"
+			text = STDIN.read
+			parser.parse(text, '(stdin)', '.')
+		else
+			parser.parse_file(path)
+		end
+	}
+	ast = parser.ast
+
+	if conf[:show_ast]
+		require 'pp'
+		$stderr.puts "AST:"
+		$stderr.puts ast.pretty_inspect
+	end
+
+	ev = MessagePack::IDL::Evaluator.new
+	ev.evaluate(ast)
+	ev.evaluate_inheritance
+	ir = ev.evaluate_spec(lang)
+
+	if conf[:show_ir]
+		require 'pp'
+		$stderr.puts "IR:"
+		$stderr.puts ir.pretty_inspect
+	end
+
+	gen = MessagePack::IDL::Generator.new
+	gen.generate(lang, ir, out)
+end
+