brotorift 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ffeb983c09de3b7835c52798bfe30d658f6f035bd337a000051cbba4a5e0bc31
+  data.tar.gz: 6b963b0f2f00c5d167780b5f2c1d3a4ec63e8aa51b05e98cbd386a15678ce03e
+SHA512:
+  metadata.gz: ad9317a9da0207ebcbf9caa079447968115f87e59e71158c815a7f126e6e20f5369465b5ea2c3ff160c690b412f1ecd9184c99a26d91040acaff1f005f78807c
+  data.tar.gz: 595c9295e383cde70247d1f4c06f207a8b81b4ec08bbbf130a7d9456198edca8831c0304c25eb5672de88d5fc25eb4bf1355e3a9f427a5c9a65ea7725216c09f

data/bin/brotorift

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+if ARGV.length < 1
+    puts 'Usage: brotorift [file_to_compile.brotorift]'
+    puts '    Please provide the brotorift file.'
+    puts
+    exit 1
+end
+
+require 'brotorift'
+brotorift = Brotorift.new
+brotorift.run ARGV[0]

data/lib/ast.rb

@@ -0,0 +1,169 @@
+require 'rltk/ast'
+require_relative 'lexer'
+
+
+module RLTK
+	class StreamPosition
+		def to_s
+			"#{file_name}(#{line_number})"
+		end
+	end
+end
+
+
+class Position
+	attr_reader :start, :stop
+
+	def initialize start, stop
+		raise "Filename should be the same." if start.file_name != stop.file_name
+		@start = start
+		@stop = stop
+	end
+
+	def to_s
+		@start.to_s
+	end
+end
+
+
+class ASTNode < RLTK::ASTNode
+	value :position, Position
+
+	def doc_str
+		if doc == ''
+			return ''
+		else
+			return " # #{doc}"
+		end
+	end
+end
+
+class TopDecl < ASTNode
+end
+
+class IncludeDecl < TopDecl
+	value :filename, String
+
+	def to_s
+		"include '#{filename}'"
+	end
+end
+
+class NodeDecl < TopDecl
+	value :name, String
+	value :language, String
+	value :nickname, String
+	value :namespace, String
+	value :doc, String
+
+	def to_s
+		nickname_str = ''
+		nickname_str = " as #{nickname}" if nickname != name
+		namespace_str = ''
+		namespace_str = " namespace #{namespace}" if namespace != ''
+		"node #{language} #{name}#{nickname_str}#{namespace_str}#{doc_str}"
+	end
+end
+
+class TypeDecl < ASTNode
+	value :name, String
+	child :params, [TypeDecl]
+
+	def to_s
+		params_str = ''
+		if params.length > 0
+			params_inner_str = params.map { |p| p.to_s } .join ','
+			params_str = '<' + params_inner_str + '>'
+		end
+		"#{name}#{params_str}"
+	end
+end
+
+class MemberDecl < ASTNode
+	value :type, TypeDecl
+	value :name, String
+	value :doc, String
+
+	def to_s
+		"#{type} #{name}#{doc_str}\n"
+	end
+end
+
+class StructDecl < TopDecl
+	value :name, String
+	value :doc, String
+	child :members, [MemberDecl]
+
+	def to_s
+		members_str = members.join ''
+		"struct #{name}#{doc_str}\n#{members_str}end"
+	end
+end
+
+class EnumElementDecl < ASTNode
+	value :name, String
+	value :value, Integer
+	value :doc, String
+
+	def to_s
+		"#{name} = #{value}#{doc_str}\n"
+	end
+end
+
+class EnumDecl < TopDecl
+	value :name, String
+	value :doc, String
+	child :elements, [EnumElementDecl]
+
+	def to_s
+		elements_str = elements.join ''
+		"enum #{name}#{doc_str}\n#{elements_str}end"
+	end
+end
+
+class MessageDecl < ASTNode
+	value :name, String
+	value :doc, String
+	child :members, [MemberDecl]
+
+	def to_s
+		members_str = members.join ''
+		"message #{name}#{doc_str}\n#{members_str}end\n"
+	end
+end
+
+class DirectionDecl < TopDecl
+	value :client, String
+	value :direction, Symbol
+	value :server, String
+	value :doc, String
+	child :messages, [MessageDecl]
+
+	def to_s
+		messages_str = messages.join ''
+		"direction #{client} #{direction} #{server}#{doc_str}\n#{messages_str}end"
+	end
+end
+
+class StepDecl < ASTNode
+	value :client, String
+	value :direction, Symbol
+	value :server, String
+	value :message, String
+	value :doc, String
+
+	def to_s
+		"#{client} #{direction} #{server}: #{message}#{doc_str}\n"
+	end
+end
+
+class SequenceDecl < TopDecl
+	value :name, String
+	value :doc, String
+	child :steps, [StepDecl]
+
+	def to_s
+		steps_str = steps.join ''
+		"sequence #{name}#{doc_str}\n#{steps_str}end"
+	end
+end

data/lib/brotorift.rb

@@ -0,0 +1,102 @@
+require 'colorize'
+require_relative 'compiler'
+require_relative 'sequence_diagram_generator'
+
+
+class Generator
+	attr_reader :language, :side
+
+	@@generators = []
+
+	def initialize language, side
+		@language = language
+		@side = side
+	end
+
+	def self.add generator
+		@@generators.push generator
+	end
+
+	def self.generators
+		@@generators
+	end
+end
+
+
+class Brotorift
+	def initialize
+		@generated_nodes = {}
+	end
+
+	def load_generators
+		root_folder = File.expand_path File.dirname __FILE__
+		generators_pattern = root_folder + '/generators/*.rb'
+		Dir.glob generators_pattern do |generator_file|
+			require generator_file
+		end
+	end
+	
+	
+	def print_compile_errors errors
+		errors.each do |e|
+			puts e
+		end
+		puts 'Your brotorift files contain errors. Please fix them before go on.'.red
+	end
+	
+	
+	def generate_all_code runtime
+		runtime.directions.each do |direction|
+			generate_code runtime, direction.client, :client
+			generate_code runtime, direction.server, :server
+		end
+	
+		generate_sequence_diagrams runtime
+	end
+	
+	
+	def generate_sequence_diagrams runtime
+		begin
+			Dir.mkdir 'docs'
+			Dir.mkdir 'docs/diagrams'
+		rescue
+		end
+		SequenceDiagramGenerator.generate runtime
+	end
+	
+	
+	def generate_code runtime, node, side
+		old_sides = @generated_nodes[node.name]
+		return if old_sides != nil and old_sides.include? side
+	
+		generator = find_generator node.language, side
+		if generator == nil
+			puts "Generator for language '#{node.language}' and side #{side} is not found.".red
+			return
+		end
+	
+		puts "Generating #{node.language} #{side} code for node '#{node.name}'..."
+		generator.generate node, runtime
+		if old_sides != nil
+			old_sides.push side
+		else
+			@generated_nodes[node.name] = [side]
+		end
+	end
+	
+	def find_generator language, side
+		Generator.generators.find { |g| g.language == language and g.side == side }
+	end
+	
+	def run file_name
+		load_generators
+		compiler = Compiler.new
+		compiler.compile file_name
+		if compiler.errors.length > 0
+			print_compile_errors compiler.errors
+			exit 1
+		else
+			generate_all_code compiler.runtime
+		end
+	end
+end

data/lib/case_helper.rb

@@ -0,0 +1,13 @@
+class String
+	def decapitalize
+		self[0].downcase + self[1..-1]
+	end
+
+	def underscore
+        self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+end

data/lib/compiler.rb

@@ -0,0 +1,288 @@
+require_relative 'parser'
+require_relative 'compiler_error'
+require_relative 'runtime'
+
+
+class String
+	def char_case
+		if self == self.upcase
+			return :upper
+		else
+			return :lower
+		end
+	end
+end
+
+
+class Compiler
+	attr_reader :errors, :runtime
+
+	def initialize
+		@errors = []
+		@message_base_id = 0
+		@message_id = 0
+	end
+
+	def compile filename
+		@runtime = self.compile_file filename
+	end
+
+	def compile_file filename
+		content = File.read filename, encoding: 'utf-8'
+		tokens = Lexer::lex content, filename
+		begin
+			ast = Parser::parse tokens
+		rescue RLTK::NotInLanguage => e
+			add_error UnexpectedTokenError.new e.current
+			return
+		end
+		runtime = Runtime.new filename
+		self.compile_ast runtime, ast
+		runtime
+	end
+
+	def compile_ast runtime, ast
+		@runtime = runtime
+		ast.each do |decl|
+			begin
+				case decl
+				when IncludeDecl
+					compile_include decl
+				when EnumDecl
+					compile_enum decl
+				when NodeDecl
+					compile_node decl
+				when StructDecl
+					compile_struct decl
+				when DirectionDecl
+					compile_direction decl
+				when SequenceDecl
+					compile_sequence decl
+				end
+			rescue CompilerError => e
+				@errors.push e
+			end
+		end
+	end
+
+	def compile_include include_ast
+		filename = include_ast.filename + '.b'
+		if not File.exists? filename
+			add_error IncludeFileNotFoundError.new filename, include_ast.position
+			return
+		end
+		include_runtime = self.compile_file filename
+		@runtime.add_include include_runtime
+	end
+
+	def compile_enum enum_ast
+		self.check_case 'enum', :upper, enum_ast
+		self.check_type_unique enum_ast
+		enum_def = EnumTypeDef.new enum_ast
+		enum_ast.elements.each do |element_ast|
+			self.check_case 'enum element', :upper, element_ast
+			self.check_unique 'enum element', enum_def.elements[element_ast.name], element_ast
+			element_def = EnumElementDef.new element_ast
+			enum_def.add_element element_def
+		end
+		@runtime.add_enum enum_def
+	end
+
+	def compile_node node_ast
+		self.check_case 'node', :upper, node_ast
+		self.check_case 'node_nick', :upper, node_ast
+		self.check_unique 'node', @runtime.nodes[node_ast.name], node_ast
+		self.check_unique 'node', @runtime.nodes[node_ast.nickname], node_ast
+		node_def = NodeDef.new node_ast
+		@runtime.add_node node_def
+	end
+
+	def compile_struct struct_ast
+		self.check_case 'struct', :upper, struct_ast
+		self.check_type_unique struct_ast
+		struct_def = StructTypeDef.new struct_ast
+		struct_ast.members.each do |member_ast|
+			self.check_case 'struct member', :lower, member_ast
+			self.check_unique 'struct member', struct_def.get_member(member_ast.name), member_ast
+			member_type_def = self.get_member_type @runtime.nodes.values, member_ast.type
+			member_def = MemberDef.new member_ast, member_type_def
+			struct_def.add_member member_def
+		end
+		@runtime.add_struct struct_def
+	end
+
+	def compile_direction direction_ast
+		client = @runtime.nodes[direction_ast.client]
+		if client == nil
+			add_error NodeNotFoundError.new direction_ast, direction_ast.client
+			return
+		end
+
+		server = @runtime.nodes[direction_ast.server]
+		if server == nil
+			add_error NodeNotFoundError.new direction_ast, direction_ast.server
+			return
+		end
+
+		if client == server
+			add_error ClientServerSameError.new direction_ast
+			return
+		end
+
+		@message_base_id += 1000
+		@message_id = 0
+
+		old_direction = @runtime.get_direction client, direction_ast.direction, server
+		self.check_unique 'direction', old_direction, direction_ast
+
+		direction_def = DirectionDef.new direction_ast, client, server
+		direction_ast.messages.each do |message_ast|
+			self.check_case 'message', :upper, message_ast
+			self.check_unique 'message', direction_def.messages[message_ast.name], message_ast
+			direction_def.add_message self.compile_message direction_def, message_ast
+		end
+		@runtime.add_direction direction_def
+	end
+
+	def compile_message direction_def, message_ast
+		@message_id += 1
+		message_def = MessageDef.new message_ast, @message_base_id + @message_id
+		message_ast.members.each do |member_ast|
+			self.check_case 'message member', :lower, member_ast
+			self.check_unique 'message member', message_def.get_member(member_ast.name), member_ast
+
+			nodes_to_check = [direction_def.client, direction_def.server]
+			member_type_def = self.get_member_type nodes_to_check, member_ast.type
+			member_def = MemberDef.new member_ast, member_type_def
+			message_def.add_member member_def
+		end
+		message_def
+	end
+
+	def compile_sequence sequence_ast
+		self.check_case 'sequence', :upper, sequence_ast
+		self.check_unique 'sequence', @runtime.get_sequence(sequence_ast.name), sequence_ast
+		sequence_def = SequenceDef.new sequence_ast
+		sequence_ast.steps.each do |step_ast|
+			sequence_def.add_step self.compile_step step_ast
+		end
+		@runtime.add_sequence sequence_def
+	end
+
+	def compile_step step_ast
+		client = @runtime.nodes[step_ast.client]
+		if client == nil
+			add_error NodeNotFoundError.new step_ast, step_ast.client
+			return nil
+		end
+
+		server = @runtime.nodes[step_ast.server]
+		if server == nil
+			add_error NodeNotFoundError.new step_ast, step_ast.server
+			return nil
+		end
+
+		if client == server
+			add_error ClientServerSameError.new step_ast
+			return nil
+		end
+
+		direction_def = @runtime.get_direction client, step_ast.direction, server
+		if direction_def == nil
+			add_error DirectionNotFoundError.new step_ast, client, step_ast.direction, server
+			return nil
+		end
+
+		message_def = direction_def.messages[step_ast.message]
+		if message_def == nil
+			add_error MessageNotFoundError.new step_ast, direction_def
+			return nil
+		end
+
+		StepDef.new step_ast, direction_def, message_def
+	end
+
+	def get_member_type nodes_to_check, member_type_ast
+		type_def, runtime = self.get_type member_type_ast, true
+		return nil if type_def == nil
+
+		params = []
+		case type_def.name
+		when 'List'
+			self.check_type_param_count member_type_ast, 1
+			params.push self.get_member_type nodes_to_check, member_type_ast.params[0]
+		when 'Set'
+			self.check_type_param_count member_type_ast, 1
+			params.push self.get_member_type nodes_to_check, member_type_ast.params[0]
+		when 'Map'
+			self.check_type_param_count member_type_ast, 2
+			params.push self.get_member_type nodes_to_check, member_type_ast.params[0]
+			params.push self.get_member_type nodes_to_check, member_type_ast.params[1]
+		else
+			self.check_type_param_count member_type_ast, 0
+		end
+
+		member_type_def = TypeInstanceDef.new member_type_ast, type_def, params, runtime
+		self.check_type_nodes member_type_ast, member_type_def
+		member_type_def
+	end
+
+	def check_type_nodes member_type_ast, member_type_def
+		return if @runtime == member_type_def.runtime
+
+		@runtime.nodes.each do |n|
+			external_node = member_type_def.runtime.nodes.find { |node| n.name == node.name }
+			if external_node == nil
+				add_error CorrespondingNodeNotFoundError.new member_type_def, n.name
+				return
+			end
+
+			if external_node.language != n.language
+				add_error NodeLanguageMismatchError.new member_type_def, n, external_node
+				return
+			end
+		end
+	end
+
+	def get_type ast, raise_error
+		return nil if ast == nil
+		
+		type_def, runtime = @runtime.get_type ast.name
+		return type_def, runtime if type_def != nil
+
+		add_error TypeNotFoundError.new ast, ast.name if raise_error
+		return type_def, runtime
+	end
+
+	def check_case type, initial_case, ast
+		if type == 'node_nick' and initial_case != ast.nickname[0].char_case
+			add_error InitialCaseError.new type, initial_case, ast
+		elsif initial_case != ast.name[0].char_case
+			add_error InitialCaseError.new type, initial_case, ast
+		end
+	end
+
+	def check_type_unique ast
+		type_def, _ = self.get_type ast, false
+		return if type_def == nil
+
+		if type_def.is_a? BuiltinTypeDef
+			add_error BuiltinNameConflictError.new ast
+		else
+			self.check_unique 'type', type_def, ast
+		end
+	end
+
+	def check_unique type, old_def, new_ast
+		return if old_def == nil
+		add_error DuplicateDefError.new type, old_def.name, old_def.ast, new_ast
+	end
+
+	def check_type_param_count ast, expected_count
+		add_error TypeParamCountMismatchError.new ast, expected_count if ast.params.length != expected_count
+	end
+
+	def add_error error
+		@errors.push error
+	end
+end