shift-lang 0.1.1

data/lib/shift-lang/generator/ruby_templates.rb

@@ -0,0 +1,50 @@
+module Shift
+	module Generator
+		module RubyTemplates
+			IMPORT_SINATRA_STATEMENT = "require 'sinatra'"
+
+			IMPORT_MUSTACHE_STATEMENT = "require 'mustache/sinatra'\n$mu_root = 'views/'"
+
+			IMPORT_DATAMAPPER_STATEMENT = "require 'data_mapper'\n"
+
+			MODEL_NAME_TEMPLATE = "class <%= model_name %>"
+			
+			DATAMAPPER_INCLUDE_STATEMENT = "include DataMapper::Resource"
+
+			DB_STRING_PROPERTY = "Text"
+
+			DB_INTEGER_PROPERTY = "Integer"
+
+			UTILITY_FUNCTIONS = '
+def read_file(file_name) 
+	f = open($mu_root + file_name,"r")
+	template = f.read()
+	f.close()
+	template
+end
+
+def read_template(file_name, template_values = nil)
+	template = read_file(file_name)
+	if (template_values == nil)
+		template
+	else
+		Mustache.render(template, template_values)
+	end
+end'
+
+			CONFIGURE_BLOCK = '
+configure :development do
+	DataMapper.setup(:default, (ENV["DATABASE_URL"] || "sqlite3://#{Dir.pwd}/test1.db"))
+	DataMapper.finalize.auto_upgrade!
+end'
+
+			WRITE_DATA_TEMPLATE = "response_result = <%= write_data %>"
+
+			WRITE_RESPONSE_TEMPLATE = '"#{response_result}"'
+
+			WRITE_FILE_TEMPLATE = "read_template(<%= file_name %><% if template_values %>, <%= template_values %><% end %>)"
+				
+			REDIRECT_STATEMENT_TEMPLATE = "redirect(<%= url %>)"
+		end
+	end
+end

data/lib/shift-lang/generator.rb

@@ -0,0 +1,41 @@
+require_relative 'generator/python_generator'
+require_relative 'generator/ruby_generator'
+require_relative 'generator/javascript_generator'
+
+module Shift
+	module Generator
+		def Generator::generatePython(files)
+			generator = Shift::Generator::PythonGenerator.new
+
+			files.each { | file | generator.get_data_from_file file }
+			
+			if(generator.builder.clean)
+				generator.write_data
+			else
+				""
+			end
+		end
+		def Generator::generateRuby(files)
+			generator = Shift::Generator::RubyGenerator.new
+
+			files.each { | file | generator.get_data_from_file file }
+			
+			if(generator.builder.clean)
+				generator.write_data
+			else
+				""
+			end
+		end
+		def Generator::generateJavaScript(files)
+			generator = Shift::Generator::JavaScriptGenerator.new
+
+			files.each { | file | generator.get_data_from_file file }
+			
+			if(generator.builder.clean)
+				generator.write_data
+			else
+				""
+			end
+		end
+	end
+end

data/lib/shift-lang/parser/control_statement_parser.rb

@@ -0,0 +1,17 @@
+require 'parslet'
+
+module Shift
+	module Parser
+		include Parslet
+
+		rule(:if_statement) { if_keyword >> space >> (conditional_statement | boolean_valued_expression).as(:condition)}
+
+		rule(:for_statement) { for_keyword >> space >> primitives >> in_keyword >> primitives }
+
+		rule(:while_statement) { while_keyword >> space >> (conditional_statement | boolean_valued_expression).as(:condition) }
+
+
+		rule(:control_statement) { if_statement.as(:if_statement) | else_keyword.as(:else_statement) | for_statement.as(:for_statement) | while_statement.as(:while_statement) }
+
+	end
+end

data/lib/shift-lang/parser/db_query_parser.rb

@@ -0,0 +1,20 @@
+require 'parslet'
+
+module Shift
+	module Parser
+		include Parslet
+
+		rule(:cud_keyword) { new_keyword | all_keyword | update_keyword | delete_keyword }
+
+		rule(:cud_query) { cud_keyword.as(:operation) >> space >> identifier.as(:model_name) }
+
+		rule(:find_by_id_query) { find_by_id_keyword.as(:operation) >> space >> identifier.as(:model_name) >> variables.as(:item_id) }
+
+		rule(:find_condition) { space? >> identifier.as(:attribute) >> space? >> query_find_operator.as(:operator) >> space? >> value_returning_expression.as(:value) >> space?}
+
+		rule(:find_query) { find_keyword.as(:operation) >> space >> identifier.as(:model_name) >> space >> where_keyword >> find_condition.as(:condition) >> (space? >> comma >> space? >> find_condition.as(:condition)).repeat(0) }
+
+		rule(:query) { find_query.as(:query) | find_by_id_query.as(:query) | cud_query.as(:query) }
+
+	end
+end

data/lib/shift-lang/parser/keyword_parser.rb

@@ -0,0 +1,52 @@
+require 'parslet'
+
+module Shift
+	module Parser
+		include Parslet
+
+		rule(:read_keyword) { str('read') }
+
+		rule(:all_keyword) { str('all') }
+
+		rule(:new_keyword) { str('new') }
+
+		rule(:find_keyword) { str('find') }
+
+		rule(:where_keyword) { str('where') }
+
+		rule(:find_by_id_keyword) { str('find_by_id') }
+
+		rule(:update_keyword) { str('update') }
+
+		rule(:delete_keyword) { str('delete') }
+
+		rule(:write_keyword) { str('write') }
+
+		rule(:write_file_keyword) { str('write_file') }
+
+		rule(:redirect_keyword) { str('redirect') }
+
+		rule(:if_keyword) { str('if') }
+
+		rule(:else_keyword) { str('else') }
+
+		rule(:for_keyword) { str('for') }
+
+		rule(:in_keyword) { str('in') }
+
+		rule(:while_keyword) { str('while') }
+
+		rule(:get_keyword) { str('get') }
+
+		rule(:post_keyword) { str('post') }
+
+		rule(:model_keyword) { str('model') }
+
+		rule(:string_keyword) { str('string') }
+
+		rule(:integer_keyword) { str('integer') }
+
+		rule(:integer_cast_keyword) { str('int') }
+	
+	end
+end 

data/lib/shift-lang/parser/operator_parser.rb

@@ -0,0 +1,35 @@
+require 'parslet'
+
+module Shift
+	module Parser
+		include Parslet
+
+		rule(:addition_operator) { space? >> str('+') >> space? }
+		rule(:subtraction_operator) { space? >> str('-') >> space? }
+		rule(:multiplication_operator) { space? >> str('*') >> space? }
+		rule(:division_operator) { space? >> str('/') >> space? }
+
+		rule(:arithmetic_operator) { addition_operator | subtraction_operator | multiplication_operator | division_operator }
+
+
+		rule(:and_operator) { space? >> str('&&') >> space? }
+		rule(:or_operator) { space? >> str('||') >> space? }
+		rule(:not_operator) { space? >> str('!') }
+
+		rule(:boolean_operator) { and_operator | or_operator }
+
+		
+		rule(:assignment_operator) { space? >> str("=") >> space? }
+
+		rule(:less_than_operator) { space? >> str("<") >> space? }
+		rule(:greater_than_operator) { space? >> str(">") >> space? }
+		rule(:equal_to_operator) { space? >> str("==") >> space? }
+		rule(:less_than_or_equal_to_operator) { space? >> str("<=") >> space? }
+		rule(:greater_than_or_equal_to_operator) { space? >> str(">=") >> space? }
+		rule(:not_equal_to_operator) { space? >> str("!=") >> space? }
+
+		rule(:conditional_operator) { less_than_or_equal_to_operator | greater_than_or_equal_to_operator | not_equal_to_operator | equal_to_operator | less_than_operator | greater_than_operator }
+
+		rule(:query_find_operator) { less_than_or_equal_to_operator | greater_than_or_equal_to_operator | not_equal_to_operator | assignment_operator | less_than_operator | greater_than_operator }
+	end
+end

data/lib/shift-lang/parser/routing_expression_parser.rb

@@ -0,0 +1,33 @@
+require 'parslet'
+
+module Shift
+	module Parser
+		include Parslet
+
+		rule(:url_method) { get_keyword.as(:url_method) | post_keyword.as(:url_method) }
+
+		rule(:url_variable) { colon >> identifier.as(:url_variable) }
+
+		rule(:url_token) { (url_variable | identifier.as(:url_token)) >> fwd_slash.maybe }
+
+		rule(:url) { fwd_slash >> url_token.repeat(0) }
+
+
+		rule(:model_definition_statement) { model_keyword >> space >> identifier.as(:model_name) }
+
+		rule(:model_attribute_type) { string_keyword | integer_keyword }
+
+		rule(:model_attribute_definition_statement) { identifier.as(:attribute_name) >> space >> model_attribute_type.as(:attribute_type) }
+
+		rule(:model_definition) { model_definition_statement.as(:model_definition_statement) | model_attribute_definition_statement.as(:model_attribute_definition_statement) }
+
+
+		rule(:write_statement) { write_keyword >> space >> string_valued_expression.as(:write_statement_param) }
+
+		rule(:write_file_statement) { write_file_keyword >> space >> string_valued_expression.as(:file_name) >> (space? >> comma >> space? >> variables).as(:template_values).repeat(0) }
+	
+
+		rule(:redirect_statement) { redirect_keyword >> space >> string_valued_expression.as(:redirect_statement_param) }
+
+	end
+end

data/lib/shift-lang/parser/simple_expression_parser.rb

@@ -0,0 +1,87 @@
+require 'parslet'
+
+module Shift
+	module Parser
+		include Parslet
+
+		rule(:right_arithmetic_expression) { arithmetic_operator >> numeric_value }
+
+		rule(:simple_arithmetic_expression) { numeric_value >> arithmetic_operator >> numeric_value }
+
+		rule(:nested_arithmetic_expression) { simple_arithmetic_expression >> right_arithmetic_expression.repeat(0) }
+
+		rule(:simple_numeric_valued_expression) { nested_arithmetic_expression | number | variables }
+
+		rule(:parenthesized_arithmetic_expression) { lparen >> simple_numeric_valued_expression >> rparen }
+
+		rule(:parenthesized_right_arithmetic_expression) { arithmetic_operator >> parenthesized_arithmetic_expression }
+
+		rule(:nested_parenthesized_right_arithmetic_expression) { arithmetic_operator >> nested_parenthesized_arithmetic_expression }
+
+		rule(:simple_parenthesized_arithmetic_expression) { parenthesized_arithmetic_expression >> (parenthesized_right_arithmetic_expression | right_arithmetic_expression).repeat(0) }
+
+		rule(:nested_parenthesized_arithmetic_expression) { lparen >> simple_parenthesized_arithmetic_expression >> rparen }
+
+		rule(:nested_parenthesized_right_arithmetic_expression) { arithmetic_operator >> nested_parenthesized_arithmetic_expression }
+
+		rule(:arithmetic_expression) { (nested_parenthesized_arithmetic_expression | simple_parenthesized_arithmetic_expression | simple_numeric_valued_expression) >> (nested_parenthesized_right_arithmetic_expression | parenthesized_right_arithmetic_expression | right_arithmetic_expression).repeat(0)}
+
+		rule(:parenthesized_numeric_valued_expression) { lparen >> (arithmetic_expression | simple_numeric_valued_expression) >> rparen }
+
+		rule(:unparenthesized_numeric_valued_expression) { arithmetic_expression.as(:arithmetic_expression) | simple_numeric_valued_expression.as(:arithmetic_expression) }
+
+		rule(:numeric_valued_expression) { unparenthesized_numeric_valued_expression | parenthesized_numeric_valued_expression.as(:arithmetic_expression) }
+
+
+		rule(:boolean_operand) { conditional_statement | primitives }
+
+		rule(:right_boolean_expression) { boolean_operator >> boolean_operand }
+
+		rule(:simple_not_expression) { not_operator >> boolean_operand }
+
+		rule(:simple_binary_boolean_expression) { boolean_operand >> (and_operator | or_operator) >> boolean_operand }
+
+		rule(:simple_boolean_expression) { simple_binary_boolean_expression | simple_not_expression }
+
+		rule(:nested_boolean_expression) { simple_boolean_expression >> right_boolean_expression.repeat(0) }
+
+		rule(:parenthesized_simple_boolean_expression) { lparen >> simple_boolean_expression >> rparen }
+
+		rule(:parenthesized_nested_right_boolean_expression) { boolean_operator >> parenthesized_simple_boolean_expression }
+
+		rule(:parenthesized_nested_boolean_expression) { parenthesized_simple_boolean_expression >> parenthesized_nested_right_boolean_expression.repeat(0) }
+
+		rule(:parenthesized_boolean_expression) { parenthesized_nested_boolean_expression | parenthesized_simple_boolean_expression }
+
+		rule(:unparenthesized_boolean_valued_expression) { parenthesized_boolean_expression | nested_boolean_expression }
+
+		rule(:parenthesized_boolean_valued_expression) { lparen >> unparenthesized_boolean_valued_expression >> rparen }
+
+		rule(:not_expression) { not_operator >> (unparenthesized_boolean_valued_expression | parenthesized_boolean_valued_expression) }
+
+		rule(:boolean_valued_expression) { unparenthesized_boolean_valued_expression.as(:boolean_expression) | parenthesized_boolean_valued_expression.as(:boolean_expression) | not_expression.as(:boolean_expression)}
+
+
+
+		rule(:right_conditional_expression) { conditional_operator >> primitives }
+
+		rule(:simple_conditional_expression) { primitives >> conditional_operator >> primitives }
+
+		rule(:nested_conditional_expression) { simple_conditional_expression >> right_conditional_expression.repeat(0) }
+
+		rule(:parenthesized_simple_conditional_expression) { lparen >> simple_conditional_expression >> rparen }
+
+		rule(:parenthesized_nested_right_conditional_expression) { conditional_operator >> parenthesized_simple_conditional_expression }
+
+		rule(:parenthesized_nested_conditional_expression) { parenthesized_simple_conditional_expression >> parenthesized_nested_right_conditional_expression.repeat(0) }
+
+		rule(:parenthesized_conditional_expression) { parenthesized_nested_conditional_expression | parenthesized_simple_conditional_expression }
+
+		rule(:unparenthesized_conditional_statement) { parenthesized_conditional_expression | nested_conditional_expression }
+
+		rule(:parenthesized_conditional_statement) { lparen >> unparenthesized_conditional_statement >> rparen }
+
+		rule(:conditional_statement) { parenthesized_conditional_statement | unparenthesized_conditional_statement }
+
+	end
+end

data/lib/shift-lang/parser/token_parser.rb

@@ -0,0 +1,69 @@
+require 'parslet'
+
+module Shift
+	module Parser
+		include Parslet
+		
+		rule(:dot) { str(".") }
+		rule(:comma) { str(",") }
+		rule(:space) { str(" ") }
+		rule(:space?) { space.maybe }
+
+		rule(:colon) { str(":") }
+		rule(:fwd_slash) { str("/") }
+		
+		rule(:single_quotes) { str("'") }
+		rule(:double_quotes) { str('"') }
+
+		rule(:lparen) { str("(") }
+		rule(:rparen) { str(")") }
+
+		rule(:left_square_bracket) { str('[') }
+		rule(:right_square_bracket) { str(']') }
+
+		rule(:integer) { match('[0-9]').repeat(1) }
+		rule(:floating_point_number) { integer >> dot >> integer }
+
+		rule(:number) { space? >> (floating_point_number | integer) >> space? }
+
+		rule(:word) { space? >> match('[\w]').repeat(1) >> space? }
+
+		rule :single_quoted_string do
+			single_quotes >> 
+			(
+				(str('\\') >> any) |
+				(single_quotes.absent? >> any)
+			).repeat >> 
+			single_quotes
+	  	end
+
+		rule :double_quoted_string do
+			double_quotes >> 
+			(
+				(str('\\') >> any) |
+				(double_quotes.absent? >> any)
+			).repeat >> 
+			double_quotes
+	  	end
+		rule(:string_value) { single_quoted_string | double_quoted_string }
+
+		rule(:identifier) { match('[A-Za-z]') >> match['[A-Za-z0-9_]'].repeat(0) }
+
+		rule(:hash_attribute) { string_value | identifier }
+		rule(:hash_value) { identifier >> left_square_bracket >> hash_attribute >> right_square_bracket }
+
+		rule(:object_value) { identifier >> dot >> identifier }
+
+		rule(:variables) { space? >> (object_value.as(:object_value) | hash_value.as(:hash_value) | identifier.as(:identifier)) >> space? }
+
+		rule(:string_valued_expression) { read_statement.as(:read_statement) | string_value.as(:string) | variables }
+
+		rule(:numeric_value) { number | object_value | hash_value | identifier }
+
+		rule(:simple_primitives) { space? >> (number | string_value | object_value | hash_value | identifier) >> space? }
+
+		rule(:parenthesized_primitives) { lparen >> simple_primitives >> rparen }
+
+		rule(:primitives) { parenthesized_primitives | simple_primitives }
+	end
+end

data/lib/shift-lang/parser/value_returning_expression_parser.rb

@@ -0,0 +1,18 @@
+require 'parslet'
+
+module Shift
+	module Parser
+		include Parslet		
+
+		rule(:read_statement) { read_keyword >> space >> string_valued_expression.as(:read_statement_param) }
+
+		rule(:string_concatenation_right_expression) { addition_operator >> space? >> string_valued_expression }
+
+		rule(:string_concatenation_expression) { string_valued_expression >> space? >> string_concatenation_right_expression.repeat(0) }
+
+		rule(:integer_casted_expression) { integer_cast_keyword.as(:int) >> space? >> lparen >> space? >> value_returning_expression >> space? >> rparen }
+
+		rule(:value_returning_expression) { query | read_statement.as(:read_statement) | boolean_valued_expression | conditional_statement.as(:conditional_statement) | string_concatenation_expression | string_valued_expression | numeric_valued_expression }
+
+	end
+end

data/lib/shift-lang/parser/void_statement_parser.rb

@@ -0,0 +1,12 @@
+require 'parslet'
+
+module Shift
+	module Parser
+		include Parslet
+
+		rule(:assignment_statement) { variables.as(:left) >> assignment_operator >> (integer_casted_expression | value_returning_expression).as(:right)}
+
+		rule(:void_statements) { url.as(:url) | url_method | model_definition | control_statement | assignment_statement.as(:assignment_statement) | write_file_statement.as(:write_file_statement) | write_statement.as(:write_statement) | redirect_statement.as(:redirect_statement) }
+
+	end
+end

data/lib/shift-lang/parser.rb

@@ -0,0 +1,120 @@
+require 'parslet'
+
+require_relative 'parser/token_parser.rb'
+require_relative 'parser/keyword_parser.rb'
+require_relative 'parser/operator_parser.rb'
+require_relative 'parser/simple_expression_parser'
+require_relative 'parser/db_query_parser'
+require_relative 'parser/value_returning_expression_parser'
+require_relative 'parser/control_statement_parser'
+require_relative 'parser/routing_expression_parser'
+require_relative 'parser/void_statement_parser'
+
+module Shift
+	class ShiftParser < Parslet::Parser
+		include Shift::Parser
+
+		rule(:expression) { void_statements | integer_casted_expression | value_returning_expression}
+		root(:expression)
+	end
+end
+
+=begin
+parser = Shift::ShiftParser.new
+
+p parser.parse("123")
+p parser.parse("123.456")
+p parser.parse("'abc'")
+p parser.parse('"def"')
+p parser.parse('"Hello World"')
+p parser.parse("test")
+p parser.parse("data[test]")
+p parser.parse("data['test']")
+p parser.parse("data.test")
+
+p parser.parse("5+5+5")
+p parser.parse("5*5")
+p parser.parse("(5+5)")
+p parser.parse("(5)")
+p parser.parse("(5+5)+5")
+p parser.parse("(5+5)+(5)") 
+p parser.parse("(5+5)*(5-5)")
+p parser.parse("(5+5)*(5-5)-(2+2)")
+p parser.parse("(5+5)* (5-5)")
+p parser.parse("((5 + 5) * (10 - 10))")
+p parser.parse("((5 + 5) * (10 - 10)) * (5 + 4)")
+p parser.parse("((5 + 5) * (10 - 10)) * ((5 + 4) * (5+5))")
+p parser.parse("(((5 + 5) * (10 - 10)) * ((5 + 4) * (5+5)))")
+
+p parser.parse("a && b")
+p parser.parse("a && b || c")
+p parser.parse("(a && b)")
+p parser.parse("(a && b) || (c || d)")
+p parser.parse("(a && b) || (c || d) || (e && f)")
+p parser.parse("((a && b) || (c || d) || (e && f))")
+
+
+p parser.parse("a == b")
+p parser.parse("a <= b")
+p parser.parse("a >= b")
+p parser.parse("a != b")
+p parser.parse("a < b")
+p parser.parse("a > b")
+p parser.parse("(a == b)")
+
+p parser.parse("(a == b) && (c == d)")
+p parser.parse("(a == b) || (c == d)")
+p parser.parse("!(c == d)")
+p parser.parse("!((a == b) || (c == d) && (e == f))")
+
+
+p parser.parse("read abc")
+p parser.parse("read 'abc'")
+p parser.parse("read read 'abc'")
+
+p parser.parse("all Todo")
+p parser.parse("new Todo")
+p parser.parse("update Todo")
+p parser.parse("delete Todo")
+p parser.parse("find_by_id Todo data")
+p parser.parse("find_by_id Todo data['id']")
+
+p parser.parse("a = 5")
+p parser.parse("a = 5 + 10")
+p parser.parse("a = b")
+p parser.parse("a = read 'test'")
+
+p parser.parse("write 'test'")
+p parser.parse('write_file "test.html"')
+
+p parser.parse("redirect '/'")
+
+# NOTE: Control statements do not have parenthesis
+
+p parser.parse("if a == b")
+p parser.parse("if (a == b)")
+p parser.parse("if ((a == b) && (c == d))")
+p parser.parse("else")
+p parser.parse("for todo in todos")
+p parser.parse("while (a == b)")
+p parser.parse("while !((a == 'b') && (c == d))")
+
+p parser.parse("get")
+p parser.parse("post")
+
+p parser.parse("/")
+p parser.parse("/todos")
+p parser.parse("/todos/new")
+p parser.parse("/todos/:id/")
+p parser.parse("/todos/:id/edit")
+
+p parser.parse("model Todo")
+
+p parser.parse("entry string")
+p parser.parse("priority integer")
+
+p parser.parse("int(5)")
+p parser.parse("int(a)")
+
+p parser.parse("'a'+'b' + c")
+=end

data/lib/shift-lang/version.rb

@@ -0,0 +1,3 @@
+module Shift
+	VERSION = "0.1.1"
+end