kaiser-ruby 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b9d062d700db52c37367a613f89ff577927d8b013bfea6d994e0eda03e26758
-  data.tar.gz: 6082e82328bdb866c38c50eb2765984bbded0c29c81ef2ca14fdaaee87f83a21
+  metadata.gz: e49970a2460c4b355e49a2dd465dae3035c135caa619d11b43b7b47b09166676
+  data.tar.gz: cde51c100d01c71158aa70b10af6e91400cd53322165b2a34c2d85db994a1aab
 SHA512:
-  metadata.gz: 470d1fd4008cae879d727e0de6f99abe5f3261067dbf738e70f9431f4e2c7cd04100ea64621fffefb8c6c1830821f020767d7b83209cf9f9304f4df098b0faf4
-  data.tar.gz: 41825a7a6f9bad109f36c3a2984960c9d7c4b23d27fa7aef2f60ef2ecdc6872f49898aba9793cb3c1ae8a0728c93b34d772e75da147c7f6ebae4cdd94ceb630d
+  metadata.gz: b2a0a4d21511e943449860b4058be59f186937447c7accd22fc44d8487792392baee54d33f76f6248c27478d82ef5d1702e352826d5066677f04c89cd795ce2f
+  data.tar.gz: 9f7aa127cd0a2aa13c9ba523073ea96d01aaa6ebcc104a7c1974bd8387dcba176dfa6bb1089b846f2d753693b19ed5fdd7f4bb302769dc389bbfa51034da21a8

data/CHANGELOG.md

@@ -0,0 +1,32 @@
+# 0.1
+
+- [x] Initial implementation of the Rockstar Language based using `Parslet::Parser`
+
+# 0.2
+
+- [x] Rewrote the Parser and Transform classes from scratch
+- [x] basic CLI and REPL
+- [x] Metal umlauts
+- [x] Most variable types, assignmnents, output, conditionals are working.
+
+# 0.3
+
+Language Implementation:
+
+- [x] Handle null type differently - nil in Ruby isn't really comparable to 0
+- [x] Handle mysterious type - probably this should be nil and what is now nil should be 0 instead
+- [x] Handle gt, gte, lt, lte comparisons
+- [x] Handle inequality
+- [x] While loop
+- [x] Until loop
+- [x] Break and continue
+- [x] And/Or keywords for conditionals
+- [x] Define functions
+- [x] Handle function calls
+- [x] Return can return math operations directly
+
+Other stuff:
+
+- [x] FizzBuzz example is working
+- [x] Fibonacci example is working
+- [x] Added comments to resulting ruby code flow control statements, so it's easier to see where what ends. This should help making the code more readable (and easier to figure out if it's actually correct), at least while the indentation feature is not fully working yet.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kaiser-ruby (0.2.3)
+    kaiser-ruby (0.3.0)
       parslet (~> 1.8)
       thor (~> 0.20)
 

data/README.md

@@ -2,7 +2,7 @@
 
 This tool translates a file containing a program written in the [Rockstar language](https://github.com/dylanbeattie/rockstar) to Ruby code.
 
-This is still a work in progress. For details on that, see the TODO.md file.
+This is still a work in progress, however most of the language implementation is already finished and working (as are the fibonacci sequence and fizzbuzz examples in the repository). For details on what is done, see the TODO.md and CHANGELOG.md files.
 
 ## Installation
 
@@ -73,6 +73,38 @@ $ kaiser-ruby execute ./examples/assignment.rock
 
 ```
 
+Or even better, this:
+
+```
+$ kaiser-ruby execute ./examples/fibonacci.rock
+1
+1
+2
+3
+5
+8
+13
+21
+34
+55
+89
+144
+233
+377
+610
+987
+1597
+2584
+4181
+6765
+10946
+17711
+28657
+46368
+
+$
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/marcinruszkiewicz/kaiser-ruby.

data/TODO.md

@@ -1,48 +1,28 @@
 # TODO notes for KaiserRuby transpiler
 
-## Variables
+## Language Implementation
 
 - [ ] Handle pronouns - he, she, it, and others should refer to the last used variable
-
-## Types
-
-- [x] Handle null type differently - nil in Ruby isn't really comparable to 0
-- [x] Handle mysterious type - probably this should be nil and what is now nil should be 0 instead
+- [ ] Handle "Janie's got a gun"
+- [ ] Ignore comments in parentheses
 - [ ] Handle object type
-
-## Comparisons
-
-- [ ] Handle gt, gte, lt, lte comparisons
-- [ ] Handle negation
-
-## Input
-
 - [ ] Handle input from STDIN
-
-## Flow Control
-
-- [ ] While loop
-- [ ] Until loop
-- [ ] Break and continue
-
-## Functions
-
-- [ ] Define functions
-- [ ] Handle function calls
+- [ ] Function calls can be used as expressions in flow statements
+- [ ] Handle ',' instead of 'and' in function calls
+- [ ] Somehow handle function variable scope
 
 ## Examples
 
-- [ ] FizzBuzz example (should also be in tests to check if it runs)
 - [ ] Should be able to run the [Cellular Rockomata](https://github.com/Rifhutch/cellular-rocktomata)
 - [ ] Fibonacci example https://github.com/dylanbeattie/rockstar/issues/94#issuecomment-408217504
 - [ ] Math module https://gist.github.com/wrenoud/6be6f7509c88a3d8f9867ae782fb768f
 - [ ] Primality checker https://www.reddit.com/r/RockstarDevs/comments/92i6sm/primality_checker_in_rockstar/
+- [ ] Make a demo command in the CLI that runs all examples (would that even work as a gem? it should be doable somehow)
 
 ## Other stuff
 
-- [x] Test if it handles metal umlauts (Ruby shouldn't care much, but tests should be made)
-- [ ] Ignore comments in parentheses
-- [x] Nicely indent blocks
 - [ ] Fix indenting of nested blocks that doesn't really work well
-- [x] Working basic REPL
-- [ ] Add code history to the REPL
+- [ ] Add code history to the REPL
+- [ ] Make REPL work with multiline input also, not only singular lines
+- [ ] Better error handling
+- [ ] Suppress warnign about eval from Thor

data/lib/kaiser_ruby.rb

@@ -18,6 +18,7 @@ module KaiserRuby
   end
 
   def self.parse(input)
+    # strings without a line ending (or single lines) should be fed into the alternative parser
     if input.split("\n").size == 1
       KaiserRuby::RockstarSingleLineParser.new.parse(input.chomp)
     else

data/lib/kaiser_ruby/cli.rb

@@ -39,6 +39,8 @@ module KaiserRuby
     def rock
       say "Type 'exit' to exit the console. Otherwise, rock on!"
 
+      # grab the outside block's binding, so that we can use it to eval code
+      # this makes it not lose local variables throughout the loop
       b = binding
 
       begin

data/lib/kaiser_ruby/rockstar_parser.rb

@@ -1,10 +1,15 @@
 module KaiserRuby
   class RockstarParser < Parslet::Parser
+    # ORDER OF THESE RULES ABSOLUTELY MATTERS
+    # DON'T MESS WITH IT
+
+    # all the keywords separately, so that variable names can't use them
+
     rule(:reserved) do
       mysterious_value_keywords | null_value_keywords | true_value_keywords | false_value_keywords |
-      plus_keywords | minus_keywords | times_keywords | over_keywords |
-      str('Knock') | str('Build') | str('Put') | str('into') | str('says') |
-      poetic_number_keywords | say_keywords
+      plus_keywords | minus_keywords | times_keywords | over_keywords | increment_keywords |
+      assignment_keywords | poetic_string_keywords | poetic_number_keywords |
+      say_keywords | flow_keywords | comparison_keywords | function_keywords
     end
 
     rule(:mysterious_value_keywords) { str('mysterious') }
@@ -19,6 +24,14 @@ module KaiserRuby
     rule(:poetic_number_keywords) { str('is') | str('was') | str('were') }
     rule(:say_keywords) { str('Say') | str('Shout') | str('Scream') | str('Whisper') }
     rule(:flow_keywords) { str('If') | str('Else') | str('While') | str('Until') }
+    rule(:increment_keywords) { str('Knock') | str('Build') }
+    rule(:assignment_keywords) { str('Put') | str('into') }
+    rule(:poetic_string_keywords) { str('says') }
+    rule(:comparison_keywords) { str("is") | not_keywords | gt_keywords | gte_keywords | lt_keywords | lte_keywords }
+    rule(:function_keywords) { str('Break it down') | str('Take it to the top') | str('Give back') | str('takes') | str('taking') }
+
+    # variable names
+    # using [[:upper:]] etc here allows for metal umlauts and other UTF characters
 
     rule(:proper_word) { reserved.absent? >> match['[[:upper:]]'] >> match['[[:alpha:]]'].repeat }
     rule(:common_variable_name) do
@@ -28,16 +41,18 @@ module KaiserRuby
         str('The ') | str('the ') |
         str('My ') | str('my ') |
         str('Your ') | str('your ')
-      ) >> reserved.absent? >> match['[[:lower:]]'].repeat
+      ) >> reserved.absent? >> match['[[:lower:]]'].repeat >> match[','].maybe.ignore
     end
     rule(:proper_variable_name) do
-      (proper_word >> (space >> proper_word).repeat).repeat(1)
+      (proper_word >> (space >> proper_word).repeat) >> match[','].maybe.ignore
     end
 
     rule(:variable_names) do
       (common_variable_name | proper_variable_name).as(:variable_name)
     end
 
+    # all the different value types (except Object for now)
+
     rule(:mysterious_value) { mysterious_value_keywords.as(:mysterious_value) }
     rule(:null_value) { null_value_keywords.as(:null_value) }
     rule(:true_value) { true_value_keywords.as(:true_value) }
@@ -47,6 +62,8 @@ module KaiserRuby
     rule(:unquoted_string) { match['^\n'].repeat.as(:unquoted_string) }
     rule(:string_as_number) { reserved.absent? >> match['^\n'].repeat.as(:string_as_number) }
 
+    # assignment
+
     rule(:basic_assignment_expression) do
       match('Put ').present? >>
       (
@@ -54,6 +71,8 @@ module KaiserRuby
       ).as(:assignment)
     end
 
+    # math operations
+
     rule(:increment) do
       (
         str('Build ') >> variable_names.as(:variable_name) >> str(' up')
@@ -66,8 +85,6 @@ module KaiserRuby
       ).as(:decrement)
     end
 
-    # math operations
-
     rule(:addition) do
       (match('.*? plus') | match('.*? with')).present? >>
       (
@@ -96,6 +113,27 @@ module KaiserRuby
       ).as(:multiplication)
     end
 
+    # functions
+
+    rule(:function) do
+      match('.*? takes').present? >>
+      (
+        variable_names.as(:function_name) >> str(' takes') >>
+        (space >> str('and ').maybe >> variable_names.as(:argument_name)).repeat.as(:arguments) >> eol >>
+        scope {
+          inner_block_line.repeat.as(:function_block) >>
+          (eol | eof).as(:enddef)
+        }
+      ).as(:function_definition)
+    end
+
+    rule(:function_call) do
+      (
+        variable_names.as(:function_name) >> str(' taking') >>
+        (space >> str('and ').maybe >> variable_names.as(:argument_name)).repeat.as(:arguments)
+      ).as(:function_call)
+    end
+
     # poetic assignments
 
     rule(:poetic_type_literal) do
@@ -118,35 +156,85 @@ module KaiserRuby
       ).as(:assignment)
     end
 
+    # single statements
+
     rule(:print_function) do
       (
         say_keywords >> space >> value_or_variable.as(:output)
       ).as(:print)
     end
 
+    rule(:break_function) do
+      str('Break it down').as(:break)
+    end
+
+    rule(:continue_function) do
+      str('Take it to the top').as(:continue)
+    end
+
+    rule(:return_function) do
+      str('Give back ') >> (math_operations | value_or_variable).as(:return_value)
+    end
+
     # comparisons
 
     rule(:equality) do
       (
-        value_or_variable.as(:left) >> str(' is ') >> (string_as_number | value_or_variable).as(:right)
+        value_or_variable.as(:left) >> str(' is ') >> value_or_variable.as(:right)
       ).as(:equals)
     end
 
-    # flow control
+    rule(:not_keywords) { str(' is not ') | str(" ain't ")}
+    rule(:inequality) do
+      (
+        value_or_variable.as(:left) >> not_keywords >> value_or_variable.as(:right)
+      ).as(:not_equals)
+    end
+
+    rule(:gt_keywords) { str(' is ') >> (str('higher') | str('greater') | str('bigger') | str('stronger')) >> str(' than ') }
+    rule(:gt) do
+      (
+        value_or_variable.as(:left) >> gt_keywords >> value_or_variable.as(:right)
+      ).as(:gt)
+    end
+
+    rule(:lt_keywords) { str(' is ') >> (str('lower') | str('less') | str('smaller') | str('weaker')) >> str(' than ') }
+    rule(:lt) do
+      (
+        value_or_variable.as(:left) >> lt_keywords >> value_or_variable.as(:right)
+      ).as(:lt)
+    end
+
+    rule(:gte_keywords) { str(' is as ') >> (str('high') | str('great') | str('big') | str('strong')) >> str(' as ') }
+    rule(:gte) do
+      (
+        value_or_variable.as(:left) >> gte_keywords >> value_or_variable.as(:right)
+      ).as(:gte)
+    end
+
+    rule(:lte_keywords) { str(' is as ') >> (str('low') | str('little') | str('small') | str('weak')) >> str(' as ') }
+    rule(:lte) do
+      (
+        value_or_variable.as(:left) >> lte_keywords >> value_or_variable.as(:right)
+      ).as(:lte)
+    end
+
+    # flow control - if, else, while, until
 
     rule(:if_block) do
       (
-        str('If ') >> comparisons.as(:if_condition) >> eol >>
+        str('If ') >> comparisons.as(:if_condition) >>
+          (space >> (str('and') | str('or')).as(:and_or) >> space >> comparisons.as(:second_condition)).maybe >> eol >>
           scope {
-            inner_block_line.repeat.as(:if_block) >>
-            (eol | eof).as(:endif)
-          }
+            inner_block_line.repeat.as(:if_block)
+          } >> (eol | eof).as(:endif)
       ).as(:if)
     end
 
     rule(:if_else_block) do
       (
-        str('If ') >> comparisons.as(:if_condition) >> eol >>
+        str('If ') >> comparisons.as(:if_condition) >>
+          (space >> (str('and') | str('or')).as(:and_or) >> space >> comparisons.as(:second_condition)).maybe >> eol >>
           scope {
             inner_block_line.repeat.as(:if_block)
           } >>
@@ -158,26 +246,58 @@ module KaiserRuby
       ).as(:if_else)
     end
 
+    rule(:while_block) do
+      (
+        str('While ') >> comparisons.as(:while_condition) >>
+          (space >> (str('and') | str('or')).as(:and_or) >> space >> comparisons.as(:second_condition)).maybe >> eol >>
+          scope {
+            inner_block_line.repeat.as(:while_block) >>
+            (eol | eof).as(:endwhile)
+          }
+      ).as(:while)
+    end
+
+    rule(:until_block) do
+      (
+        str('Until ') >> comparisons.as(:until_condition) >>
+          (space >> (str('and') | str('or')).as(:and_or) >> space >> comparisons.as(:second_condition)).maybe >> eol >>
+          scope {
+            inner_block_line.repeat.as(:until_block)
+
+          } >> (eol | eof).as(:enduntil)
+      ).as(:until)
+    end
+
+    # sets of rules
+
     rule(:simple_values) { mysterious_value | null_value | false_value | true_value | string_value | numeric_value }
     rule(:value_or_variable) { variable_names | simple_values }
-    rule(:expressions) { basic_assignment_expression | increment | decrement | addition | subtraction | multiplication | division }
-    rule(:comparisons) { equality }
-    rule(:flow_control) { if_block | if_else_block }
+    rule(:math_operations) { increment | decrement | addition | subtraction | multiplication | division }
+    rule(:expressions) { basic_assignment_expression | math_operations }
+    rule(:comparisons) { gte | gt | lte | lt | inequality | equality }
+    rule(:flow_control) { if_block | if_else_block | while_block | until_block }
     rule(:poetics) { poetic_type_literal | poetic_string_literal | poetic_number_literal }
-    rule(:functions) { print_function }
+    rule(:functions) { function_call | function | print_function | break_function | continue_function | return_function }
     rule(:line_elements) { flow_control | poetics | expressions | functions | eol }
 
+    # handle multiple lines in a file
+
     rule(:string_input) { line_elements | value_or_variable }
     rule(:line) { (line_elements >> eol.maybe).as(:line) }
     rule(:inner_block_line) { ( (flow_control | poetics | expressions | functions) >> eol.maybe).as(:line) }
     rule(:lyrics) { line.repeat.as(:lyrics) }
     root(:lyrics)
 
+    # DRY helpers
+
     rule(:eol) { match["\n"] }
     rule(:eof) { any.absent? }
     rule(:space) { match[' \t'].repeat(1) }
   end
 
+  # this is an alternative parser that enables all the RSpec tests to pass
+  # it specifically has a single line rule that matches a string instead of lines
+  # it also matches the value_or_variable rule, so that the value creation can be tested
   class RockstarSingleLineParser < KaiserRuby::RockstarParser
     root(:string_input)
   end

data/lib/kaiser_ruby/rockstar_transform.rb

@@ -29,18 +29,51 @@ module KaiserRuby
     rule(division: { left: simple(:left), right: simple(:right) }) { "#{left} / #{right}" }
 
     rule(print: { output: simple(:output) }) { "puts #{output}" }
+    rule(continue: simple(:_)) { "next" }
+    rule(break: simple(:_)) { "break" }
 
     rule(equals: { left: simple(:left), right: simple(:right) }) { "#{left} == #{right}" }
-    rule(if: { if_condition: simple(:if_condition), if_block: sequence(:if_block_lines), endif: simple(:_)} ) do
+    rule(not_equals: { left: simple(:left), right: simple(:right) }) { "#{left} != #{right}" }
+    rule(gt: { left: simple(:left), right: simple(:right) }) { "#{left} > #{right}" }
+    rule(gte: { left: simple(:left), right: simple(:right) }) { "#{left} >= #{right}" }
+    rule(lte: { left: simple(:left), right: simple(:right) }) { "#{left} <= #{right}" }
+    rule(lt: { left: simple(:left), right: simple(:right) }) { "#{left} < #{right}" }
+
+    rule(if: {
+      if_condition: simple(:if_condition),
+      if_block: sequence(:if_block_lines),
+      endif: simple(:_)
+    } ) do
       output = "#{' ' * KaiserRuby.indent}if #{if_condition}\n"
       KaiserRuby.up_indent
       output += if_block_lines.map { |l| "#{' ' * KaiserRuby.indent}#{l}\n" }.join
       KaiserRuby.down_indent
-      output += "#{' ' * KaiserRuby.indent}end"
+      output += "#{' ' * KaiserRuby.indent}end # endif"
+      output
+    end
+
+    rule(if: {
+      if_condition: simple(:if_condition),
+      and_or: simple(:and_or),
+      second_condition: simple(:second_condition),
+      if_block: sequence(:if_block_lines),
+      endif: simple(:_)
+    } ) do
+      proper_and_or = and_or == 'and' ? '&&' : '||'
+      output = "#{' ' * KaiserRuby.indent}if #{if_condition} #{proper_and_or} #{second_condition}\n"
+      KaiserRuby.up_indent
+      output += if_block_lines.map { |l| "#{' ' * KaiserRuby.indent}#{l}\n" }.join
+      KaiserRuby.down_indent
+      output += "#{' ' * KaiserRuby.indent}end # endif"
       output
     end
 
-    rule(if_else: { if_condition: simple(:if_condition), if_block: sequence(:if_block_lines), else_block: sequence(:else_block_lines), endif: simple(:_)} ) do
+    rule(if_else: {
+      if_condition: simple(:if_condition),
+      if_block: sequence(:if_block_lines),
+      else_block: sequence(:else_block_lines),
+      endif: simple(:_)
+    } ) do
       output = "#{' ' * KaiserRuby.indent}if #{if_condition}\n"
       KaiserRuby.up_indent
       output += if_block_lines.map { |l| "#{' ' * KaiserRuby.indent}#{l}\n" }.join
@@ -49,10 +82,113 @@ module KaiserRuby
       KaiserRuby.up_indent
       output += else_block_lines.map { |l| "#{' ' * KaiserRuby.indent}#{l}\n" }.join
       KaiserRuby.down_indent
-      output += "#{' ' * KaiserRuby.indent}end"
+      output += "#{' ' * KaiserRuby.indent}end # endifelse"
       output
     end
 
+    rule(if_else: {
+      if_condition: simple(:if_condition),
+      and_or: simple(:and_or),
+      second_condition: simple(:second_condition),
+      if_block: sequence(:if_block_lines),
+      else_block: sequence(:else_block_lines),
+      endif: simple(:_)
+    } ) do
+      proper_and_or = and_or == 'and' ? '&&' : '||'
+      output = "#{' ' * KaiserRuby.indent}if #{if_condition} #{proper_and_or} #{second_condition}\n"
+      KaiserRuby.up_indent
+      output += if_block_lines.map { |l| "#{' ' * KaiserRuby.indent}#{l}\n" }.join
+      KaiserRuby.down_indent
+      output += "#{' ' * KaiserRuby.indent}else\n"
+      KaiserRuby.up_indent
+      output += else_block_lines.map { |l| "#{' ' * KaiserRuby.indent}#{l}\n" }.join
+      KaiserRuby.down_indent
+      output += "#{' ' * KaiserRuby.indent}end # endifelse"
+      output
+    end
+
+    rule(while: {
+      while_condition: simple(:while_condition),
+      while_block: sequence(:while_block_lines),
+      endwhile: simple(:_)
+    } ) do
+      output = "#{' ' * KaiserRuby.indent}while #{while_condition}\n"
+      KaiserRuby.up_indent
+      output += while_block_lines.map { |l| "#{' ' * KaiserRuby.indent}#{l}\n" }.join
+      KaiserRuby.down_indent
+      output += "#{' ' * KaiserRuby.indent}end # endwhile"
+      output
+    end
+
+    rule(while: {
+      while_condition: simple(:while_condition),
+      and_or: simple(:and_or),
+      second_condition: simple(:second_condition),
+      while_block: sequence(:while_block_lines),
+      endwhile: simple(:_)
+    } ) do
+      proper_and_or = and_or == 'and' ? '&&' : '||'
+      output = "#{' ' * KaiserRuby.indent}while #{while_condition} #{proper_and_or} #{second_condition}\n"
+      KaiserRuby.up_indent
+      output += while_block_lines.map { |l| "#{' ' * KaiserRuby.indent}#{l}\n" }.join
+      KaiserRuby.down_indent
+      output += "#{' ' * KaiserRuby.indent}end # endwhile"
+      output
+    end
+
+    rule(until: {
+      until_condition: simple(:until_condition),
+      until_block: sequence(:until_block_lines),
+      enduntil: simple(:_)
+    } ) do
+      output = "#{' ' * KaiserRuby.indent}until #{until_condition}\n"
+      KaiserRuby.up_indent
+      output += until_block_lines.map { |l| "#{' ' * KaiserRuby.indent}#{l}\n" }.join
+      KaiserRuby.down_indent
+      output += "#{' ' * KaiserRuby.indent}end # enduntil"
+      output
+    end
+
+    rule(until: {
+      until_condition: simple(:until_condition),
+      and_or: simple(:and_or),
+      second_condition: simple(:second_condition),
+      until_block: sequence(:until_block_lines),
+      enduntil: simple(:_)
+    } ) do
+      proper_and_or = and_or == 'and' ? '&&' : '||'
+      output = "#{' ' * KaiserRuby.indent}until #{until_condition} #{proper_and_or} #{second_condition}\n"
+      KaiserRuby.up_indent
+      output += until_block_lines.map { |l| "#{' ' * KaiserRuby.indent}#{l}\n" }.join
+      KaiserRuby.down_indent
+      output += "#{' ' * KaiserRuby.indent}end # enduntil"
+      output
+    end
+
+    rule(argument_name: simple(:str)) { str }
+    rule(return_value: simple(:value)) { "return #{value}" }
+
+    rule(function_definition: {
+      function_name: simple(:function_name),
+      arguments: sequence(:arguments),
+      function_block: sequence(:function_block_lines),
+      enddef: simple(:_)
+    } ) do
+      output = "#{' ' * KaiserRuby.indent}def #{function_name}(#{arguments.join(', ')})\n"
+      KaiserRuby.up_indent
+      output += function_block_lines.map { |l| "#{' ' * KaiserRuby.indent}#{l}\n" }.join
+      KaiserRuby.down_indent
+      output += "#{' ' * KaiserRuby.indent}end # enddef"
+      output
+    end
+
+    rule(function_call: {
+      function_name: simple(:function_name),
+      arguments: sequence(:arguments)
+    } ) do
+      "#{function_name}(#{arguments.join(', ')})"
+    end
+
     rule(line: simple(:line)) { line == "\n" ? nil : line }
     rule(lyrics: sequence(:lines)) { lines.join("\n") + "\n" }
 

data/lib/kaiser_ruby/version.rb

@@ -1,3 +1,3 @@
 module KaiserRuby
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kaiser-ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Marcin Ruszkiewicz
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-03 00:00:00.000000000 Z
+date: 2018-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -105,6 +105,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt