myl-parser 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f6eee66c8c966f466c5bcd00f577bff30c12e04d
+  data.tar.gz: 53f9019cac3e714533f580f2961cd9fe79b10901
+SHA512:
+  metadata.gz: 5d504bbaf83dca795c5114e0aa6d97ec1ba21909d787eefecdff0d635e6466334ff1cf5036ff56181bb04eccb761037b3b47820372f90af3f57c911ad1a82cda
+  data.tar.gz: 37c90ae046874d0775edb1eb04e1e027c978918d4525f4a57591873947485a2604698979f42af08ae5fe4d924566ddc9cf3c29a5435f420d082f57bded565619

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+*.gemspec
+*.swp
+/.idea
+/pkg

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'treetop'
+gem 'rspec', require: 'spec'
+gem 'awesome_print'
+gem 'guard'
+gem 'guard-rspec', require: false

data/Gemfile.lock

@@ -0,0 +1,61 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    awesome_print (1.2.0)
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    celluloid-io (0.15.0)
+      celluloid (>= 0.15.0)
+      nio4r (>= 0.5.0)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    ffi (1.9.3)
+    formatador (0.2.4)
+    guard (2.6.0)
+      formatador (>= 0.2.4)
+      listen (~> 2.7)
+      lumberjack (~> 1.0)
+      pry (>= 0.9.12)
+      thor (>= 0.18.1)
+    guard-rspec (4.2.8)
+      guard (~> 2.1)
+      rspec (>= 2.14, < 4.0)
+    listen (2.7.1)
+      celluloid (>= 0.15.2)
+      celluloid-io (>= 0.15.0)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.5)
+    method_source (0.8.2)
+    nio4r (1.0.0)
+    polyglot (0.3.4)
+    pry (0.9.12.6)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.3)
+      ffi (>= 0.5.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.8)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.6)
+    slop (3.5.0)
+    thor (0.19.1)
+    timers (1.1.0)
+    treetop (1.5.3)
+      polyglot (~> 0.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  guard
+  guard-rspec
+  rspec
+  treetop

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/parser/myl_parser\.treetop$})     { "spec" }
+  watch(%r{^spec/helpers/.+_helper\.rb$}) {'spec'}
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 leo
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,8 @@
+myl
+===
+
+a simple language
+
+Based on the koi language
+
+see code_example.md for tested code and have example of what you can do

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/code_example.md

@@ -0,0 +1,286 @@
+
+```
+test = 1.0
+```
+
+```
+test = -2234.342
+```
+
+```
+test = 12134
+```
+
+```
+test = -2234
+```
+
+```
+test = 1
+```
+
+```
+test = -2
+```
+
+```
+test = true
+```
+
+```
+test = false
+```
+
+```
+test = nil
+```
+
+```
+test = "salut"
+```
+
+```
+test = "salut \"numa\" ca va"
+```
+
+```
+test = 2+2
+```
+
+```
+test = function(args)
+```
+
+```
+test = function()
+```
+
+```
+test = ident
+```
+
+```
+1 == 1
+```
+
+```
+2.3 == 2.3
+```
+
+```
+"a" == "a"
+```
+
+```
+test == test2
+```
+
+```
+1 != 2
+```
+
+```
+2.0 != 2.3
+```
+
+```
+"b" != "a"
+```
+
+```
+test != test2
+```
+
+```
+2 > 1
+```
+
+```
+2.4 > 2.3
+```
+
+```
+"b" > "a"
+```
+
+```
+test > test2
+```
+
+```
+1 < 2
+```
+
+```
+2.0 < 2.3
+```
+
+```
+"a" < "b"
+```
+
+```
+test < test2
+```
+
+```
+blup(2) + 1
+```
+
+```
+blup(2) + 1
+```
+
+```
+blup(2) + 1
+```
+
+```
+2*4+2/8
+```
+
+```
+2*4+2/8
+```
+
+```
+2*4+2/8
+```
+
+```
+2/(8+1)
+```
+
+```
+2/(8+1)
+```
+
+```
+2/(8+1)
+```
+
+```
+2+2
+```
+
+```
+2.0+ 3.9
+```
+
+```
+"saalut"+ "ça va?"
+```
+
+```
+q+ w
+```
+
+```
+2-2
+```
+
+```
+2.0 - 3.9
+```
+
+```
+"saalut"- "ça va?"
+```
+
+```
+q -w
+```
+
+```
+2*2
+```
+
+```
+2.0* 3.9
+```
+
+```
+"abc"* 3
+```
+
+```
+q* w
+```
+
+```
+2/2
+```
+
+```
+2.0/ 3.9
+```
+
+```
+"saalut"/ "ça va?"
+```
+
+```
+q/ w
+```
+
+```
+if(1 == 1) test = 1; test2 = 2; end
+```
+
+```
+if(1 == 1)
+test = 1
+test2 = 2
+end
+```
+
+```
+unless(1 == 1) test = 1; test2 = 2; end
+```
+
+```
+unless(1 == 1)
+test = 1
+test2 = 2
+end
+```
+
+```
+test()
+```
+
+```
+test(1)
+```
+
+```
+test(1)
+```
+
+```
+test(1, "abc")
+```
+
+```
+test(1, "abc")
+```
+
+```
+test(1, "abc")
+```
+
+```
+test(1, test2())
+```
+
+```
+test(1, test2())
+```
+
+```
+test(1, test2())
+```
+
+```
+test(1, test2())
+```

data/lib/myl_parser.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+
+require_files = []
+require_files.concat Dir[File.join(File.dirname(__FILE__), 'parser', '**', '*.rb')]
+
+require_files.each do |file|
+  require File.expand_path(file)
+end

data/lib/parser/exceptions.rb

@@ -0,0 +1,2 @@
+class ParseError < Exception
+end

data/lib/parser/myl_parser.treetop

@@ -0,0 +1,148 @@
+# More info on PEGs: http://en.wikipedia.org/wiki/Parsing_expression_grammar
+# More info on Treetop: http://treetop.rubyforge.org/
+
+grammar Myl
+    rule block
+        statement+ <Block>
+    end
+    rule statement
+        space? expression space? <Statement>
+    end
+
+    rule expression
+        space? (flow_control / assignment / comparative / additive) '.'? function_call? <Expression>
+    end
+
+# LITERALS
+    rule true
+        'true' <TrueLiteral>
+    end
+
+    rule false
+        'false' <FalseLiteral>
+    end
+
+    rule nil
+        'nil' <NilLiteral>
+    end
+
+    rule integer
+        ('-')? [0-9]+ <IntegerLiteral>
+    end
+
+    rule float
+        ('-')? [0-9]+ '.' [0-9]+ <FloatLiteral>
+    end
+
+    rule string
+        '"' ([^"\\] / "\\" . )* '"' <StringLiteral>
+    end
+
+    rule identifier
+        [a-zA-Z] [a-zA-Z0-9_]* ('?' / '!')? <Identifier>
+    end
+
+#END LITERALS
+
+#FUNCTION CALL
+rule function_call
+    identifier '(' space? expression? space? ','? expression? space? ')' <FunctionCall>
+end
+#END FUNCTION CALL
+
+# FLOW CONTROL
+rule flow_control
+    unless / if
+end
+
+rule if
+    'if' '('? space? expression space? ')'? space? '{'? space? block space? '}'? <If>
+end
+
+rule unless
+    'unless' '('? space? expression space? ')'? space? '{'? space? block space? '}'? <Unless>
+end
+# END FLOW CONTROL
+
+# ASSIGNMENT
+rule assignment
+    identifier space? assignment_operator space? expression <Assignment>
+end
+
+rule assignment_operator
+    '=' <AssignmentOperator>
+end
+
+#END ASSIGNMENT
+
+# MATH
+    rule comparative
+        primary space? comparative_operator space? primary <ComparativeExpression>
+    end
+    rule additive
+        multitive space? additive_operator space? additive  <AdditiveExpression>
+        /
+        multitive
+    end
+
+    rule multitive
+        primary space? multitive_operator space? multitive <MultitiveExpression>
+        /
+        primary
+    end
+
+    rule primary
+        (function_call / nil / true / false / identifier / float / integer / string)
+        /
+        '(' expression ')' <Expression>
+    end
+# END MATH
+
+# OPERATOR
+    rule comparative_operator
+        equality_operator / inequality_operator / greater_than_operator / less_than_operator
+    end
+    rule equality_operator
+        '==' <EqualityOperator>
+    end
+
+    rule inequality_operator
+        '!=' <InEqualityOperator>
+    end
+
+    rule greater_than_operator
+        '>' <GreaterThanOperator>
+    end
+
+    rule less_than_operator
+        '<' <LessThanOperator>
+    end
+
+    rule multitive_operator
+        multiplication_operator / division_operator
+    end
+
+    rule multiplication_operator
+        '*' <MultiplicationOperator>
+    end
+
+    rule division_operator
+        '/' <DivisionOperator>
+    end
+
+    rule additive_operator
+        addition_operator / subtraction_operator
+    end
+
+    rule subtraction_operator
+        '-' <SubtractionOperator>
+    end
+
+    rule addition_operator
+        '+' <AdditionOperator>
+    end
+# END OPERATOR
+    rule space
+        [\s]
+    end
+end

data/lib/parser/syntax_node_extensions.rb

@@ -0,0 +1,32 @@
+require 'treetop'
+module MylReferenceParser
+  class Treetop::Runtime::SyntaxNode
+  
+    def to_hash()
+      hash = {}
+      hash[:offset] = self.interval.first
+      hash[:text_value] = self.text_value
+      hash[:name] = self.class.name.split("::").last
+      unless( self.elements.nil? )
+        hash[:elements] = self.elements.map {|element| element.to_hash() }
+      else
+        hash[:elements] = nil
+      end
+      return hash
+    end
+
+    def get_element(nth, params = {})
+      demand_elem = get_element_rec(nth, 0, self.elements)
+      return demand_elem.elements[params[:child]] if params[:child]
+      return demand_elem
+    end
+
+    private
+
+    def get_element_rec(nth, level, rec_elements)
+      return rec_elements.last if level == nth
+      get_element_rec(nth, level+1, rec_elements.last.elements)
+    end
+  end
+
+end

data/lib/parser/syntax_nodes.rb

@@ -0,0 +1,80 @@
+module MylReferenceParser
+    
+    class Block < Treetop::Runtime::SyntaxNode
+    end
+    
+    class Statement < Treetop::Runtime::SyntaxNode
+    end
+    
+    class Assignment < Treetop::Runtime::SyntaxNode
+    end
+    
+    class If < Treetop::Runtime::SyntaxNode
+    end
+    
+    class Unless < Treetop::Runtime::SyntaxNode
+    end
+    
+    class FunctionCall < Treetop::Runtime::SyntaxNode
+    end
+    
+    class NilLiteral < Treetop::Runtime::SyntaxNode
+    end
+    
+    class TrueLiteral < Treetop::Runtime::SyntaxNode
+    end
+    
+    class FalseLiteral < Treetop::Runtime::SyntaxNode
+    end
+    
+    class IntegerLiteral < Treetop::Runtime::SyntaxNode
+    end
+    
+    class FloatLiteral < Treetop::Runtime::SyntaxNode
+    end
+    
+    class StringLiteral < Treetop::Runtime::SyntaxNode
+    end
+    
+    class Identifier < Treetop::Runtime::SyntaxNode
+    end
+    
+    class AssignmentOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class EqualityOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class InEqualityOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class GreaterThanOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class LessThanOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class AdditionOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class SubtractionOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class MultiplicationOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class DivisionOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class Expression < Treetop::Runtime::SyntaxNode
+    end
+
+    class ComparativeExpression < Treetop::Runtime::SyntaxNode
+    end
+    
+    class AdditiveExpression < Treetop::Runtime::SyntaxNode
+    end
+    
+    class MultitiveExpression < Treetop::Runtime::SyntaxNode
+    end
+end

data/lib/parser/tree_parser.rb

@@ -0,0 +1,26 @@
+class TreeParser
+  require 'treetop'
+  Treetop.load(File.expand_path(File.join(File.dirname(__FILE__), 'myl_parser.treetop')))
+  @@parser = MylParser.new
+
+  def self.parse(data)
+    tree = @@parser.parse(data)
+
+    if(tree.nil?)
+      raise ParseError, "Parse error at offset: #{@@parser.index}"
+    end
+
+    # clean up the tree by removing all nodes of default type 'SyntaxNode'
+    self.clean_tree(tree)
+
+    return tree
+  end
+
+  private
+
+    def self.clean_tree(root_node)
+      return if(root_node.elements.nil?)
+      root_node.elements.delete_if{|node| node.class.name == "Treetop::Runtime::SyntaxNode" }
+      root_node.elements.each {|node| self.clean_tree(node) }
+    end
+end

data/run_gurad.rb

@@ -0,0 +1 @@
+exec 'bundle exec guard'

data/spec/assignement/assignement_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper.rb'
+
+describe 'assignement of a' do
+  context 'float' do
+    it { parse('test = 1.0').should be_an_assignement 1.0, FloatLiteral }
+    it { parse('test = -2234.342').should be_an_assignement -2234.342, FloatLiteral }
+  end
+  context 'integer' do
+    it { parse('test = 12134').should be_an_assignement(12134, IntegerLiteral) }
+    it { parse('test = -2234').should be_an_assignement(-2234, IntegerLiteral) }
+    it { parse('test = 1').should be_an_assignement(1, IntegerLiteral) }
+    it { parse('test = -2').should be_an_assignement(-2, IntegerLiteral) }
+  end
+  context 'boolean' do
+    it { parse('test = true').should be_an_assignement true, TrueLiteral }
+    it { parse('test = false').should be_an_assignement false, FalseLiteral }
+  end
+  context 'nil' do
+    it { parse('test = nil').should be_an_assignement 'nil', NilLiteral }
+  end
+
+  context 'string' do
+    it { parse('test = "salut"').should be_an_assignement '"salut"', StringLiteral }
+    it 'with escaped quotes' do
+      parse('test = "salut \"numa\" ca va"').
+          should be_an_assignement '"salut \"numa\" ca va"', StringLiteral
+    end
+  end
+  context 'expression' do
+    it { puts parse('test = 2+2').should be_an_assignement '2+2', AdditiveExpression }
+  end
+  context 'function call' do
+    it { parse('test = function(args)').should be_an_assignement 'function(args)', FunctionCall }
+    it { parse('test = function()').should be_an_assignement 'function()', FunctionCall }
+  end
+  context 'identifier' do
+    it { parse('test = ident').should be_an_assignement 'ident', Identifier }
+  end
+end

data/spec/expressions/comparaison_expressions_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper.rb'
+
+describe 'comparaison expressions' do
+  context 'equality' do
+    it {parse('1 == 1').should be_a_full_expression ComparativeExpression, EqualityOperator}
+    it {parse('2.3 == 2.3').should be_a_full_expression ComparativeExpression, EqualityOperator}
+    it {parse('"a" == "a"').should be_a_full_expression ComparativeExpression, EqualityOperator}
+    it {parse('test == test2').should be_a_full_expression ComparativeExpression, EqualityOperator}
+  end
+  context 'inequality' do
+    it {parse('1 != 2').should be_a_full_expression ComparativeExpression, InEqualityOperator}
+    it {parse('2.0 != 2.3').should be_a_full_expression ComparativeExpression, InEqualityOperator}
+    it {parse('"b" != "a"').should be_a_full_expression ComparativeExpression, InEqualityOperator}
+    it {parse('test != test2').should be_a_full_expression ComparativeExpression, InEqualityOperator}
+  end
+  context 'greater than' do
+    it {parse('2 > 1').should be_a_full_expression ComparativeExpression, GreaterThanOperator}
+    it {parse('2.4 > 2.3').should be_a_full_expression ComparativeExpression, GreaterThanOperator}
+    it {parse('"b" > "a"').should be_a_full_expression ComparativeExpression, GreaterThanOperator}
+    it {parse('test > test2').should be_a_full_expression ComparativeExpression, GreaterThanOperator}
+  end
+  context 'less than' do
+    it {parse('1 < 2').should be_a_full_expression ComparativeExpression, LessThanOperator}
+    it {parse('2.0 < 2.3').should be_a_full_expression ComparativeExpression, LessThanOperator}
+    it {parse('"a" < "b"').should be_a_full_expression ComparativeExpression, LessThanOperator}
+    it {parse('test < test2').should be_a_full_expression ComparativeExpression, LessThanOperator}
+  end
+end

data/spec/expressions/compund_expressions_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper.rb'
+
+describe 'compound expressions' do
+  context 'has function call' do
+    subject(:result) { parse('blup(2)+ 1') }
+    it { should be_a_full_expression(AdditiveExpression, AdditionOperator) }
+    it { result.get_element(2, child: 0).should be_a FunctionCall }
+    it { result.get_element(3).should be_a IntegerLiteral }
+  end
+
+  context 'has sub expression' do
+    subject(:result) { parse('2*4+2/8') }
+    let(:expr) { result.get_element(1) }
+    it { should be_a_full_expression AdditiveExpression, AdditionOperator }
+    it { expr.get_element(0, child: 0).should be_an_expression(MultitiveExpression, MultiplicationOperator) }
+    it { expr.get_element(1).should be_an_expression(MultitiveExpression, DivisionOperator) }
+  end
+
+  context 'has parenthesis' do
+    subject(:result) { parse('2/(8+1)') }
+    let(:expr) { result.get_element(1) }
+    it { should be_a_full_expression MultitiveExpression, DivisionOperator }
+    it { result.get_element(5).should be_an_expression AdditiveExpression, AdditionOperator }
+    it { result.get_element(4).should be_a Expression }
+  end
+end

data/spec/expressions/simple_expressions_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper.rb'
+
+describe 'simple expressions' do
+  context 'addition' do
+    it { parse('2+2').should be_a_full_expression(AdditiveExpression, AdditionOperator) }
+    it { parse('2+ 3.9').should be_a_full_expression(AdditiveExpression, AdditionOperator) }
+    it { parse('"saalut"+ "ça va?"').should be_a_full_expression(AdditiveExpression, AdditionOperator) }
+    it { parse('q+ w').should be_a_full_expression(AdditiveExpression, AdditionOperator) }
+  end
+  context 'subtraction' do
+    it { parse('2-2').should be_a_full_expression(AdditiveExpression, SubtractionOperator) }
+    it { parse('2.0 - 3.9').should be_a_full_expression(AdditiveExpression, SubtractionOperator) }
+    it { parse('"saalut"- "ça va?"').should be_a_full_expression(AdditiveExpression, SubtractionOperator) }
+    it { parse('q -w').should be_a_full_expression(AdditiveExpression, SubtractionOperator) }
+  end
+  context 'multiplication' do
+    it { parse('2*2').should be_a_full_expression(MultitiveExpression, MultiplicationOperator) }
+    it { parse('2.0* 3.9').should be_a_full_expression(MultitiveExpression, MultiplicationOperator) }
+    it { parse('"abc"* 3').should be_a_full_expression(MultitiveExpression, MultiplicationOperator) }
+    it { parse('q* w').should be_a_full_expression(MultitiveExpression, MultiplicationOperator) }
+  end
+  context 'division' do
+    it { parse('2/2').should be_a_full_expression(MultitiveExpression, DivisionOperator) }
+    it { parse('2.0/ 3.9').should be_a_full_expression(MultitiveExpression, DivisionOperator) }
+    it { parse('"saalut"/ "ça va?"').should be_a_full_expression(MultitiveExpression, DivisionOperator) }
+    it { parse('q/ w').should be_a_full_expression(MultitiveExpression, DivisionOperator) }
+  end
+end

data/spec/flow_control/if_unless_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper.rb'
+
+describe 'flow control' do
+  context 'if' do
+    subject(:result) { parse('if 1 == 1 test = 1 test2 = 2 } test3=3') }
+    it { should be_a_flow_control If }
+    it { result.get_element(0, child: 0).get_element(0).text_value.should eq('test3=3') }
+  end
+
+  context 'unless' do
+    subject(:result) { parse("unless(1 == 1) {\ntest = 1\ntest2 = 2\n}\ntest=3\n") }
+    it { should be_a_flow_control Unless }
+    it { result.get_element(0, child: 0).get_element(0).text_value.should eq('test=3') }
+  end
+end

data/spec/functions/functions_call_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper.rb'
+
+describe 'function call' do
+  context 'without arguments' do
+    subject(:result) { parse('test()') }
+    it{ should be_a_function_call 'test' }
+  end
+  context 'with one argument' do
+    subject(:result) { parse('test(1)') }
+    it{ should be_a_function_call 'test' }
+    it{ result.get_element(4).should be_a IntegerLiteral }
+  end
+
+  context 'with multiple arguments' do
+    subject(:result) { parse('test(1, "abc")') }
+    it{ should be_a_function_call 'test' }
+    it{ result.get_element(2, child: 1).elements.first.should be_a IntegerLiteral }
+    it{ result.get_element(4).should be_a StringLiteral }
+  end
+
+  context 'with argument as function call' do
+    subject(:result) { parse('test(1, test2())') }
+    it{ should be_a_function_call 'test' }
+    it{ result.get_element(2, child: 1).elements.first.should be_a IntegerLiteral }
+    it{ result.get_element(4).should be_a FunctionCall }
+    it{ result.get_element(5).text_value.should eq('test2') }
+  end
+  context 'after an expression' do
+    subject(:result) { parse('2.print()') }
+    it { puts result.get_element(2).should be_a FunctionCall }
+  end
+end

data/spec/helpers/assignement_helper.rb

@@ -0,0 +1,13 @@
+RSpec::Matchers.define :be_an_assignement do |value, type|
+  match do |tree|
+    tree.should be_a Block
+    tree.get_element(0).should be_a Statement
+    tree.get_element(1).should be_a Expression
+    tree.get_element(1, child: 0).should be_a Assignment
+    tree.get_element(2, child: 0).should be_a Identifier
+    tree.get_element(2, child: 1).should be_a AssignmentOperator
+    tree.get_element(2, child: 2).should be_a Expression
+    tree.get_element(3).get_element(0).should be_a type
+    tree.get_element(3).get_element(0).text_value.should eq value.to_s
+  end
+end

data/spec/helpers/expression_helper.rb

@@ -0,0 +1,15 @@
+RSpec::Matchers.define :be_an_expression do |expression_type, operator|
+  match do |tree|
+    tree.should be_a expression_type
+    tree.elements.size.should eq 3
+    tree.elements[1].should be_a operator
+  end
+end
+
+RSpec::Matchers.define :be_a_full_expression do |expression_type, operator|
+  match do |tree|
+    tree.should be_a_statement
+    tree.get_element(1).should be_a Expression
+    tree.get_element(2).should be_an_expression expression_type, operator
+  end
+end

data/spec/helpers/flow_control_helper.rb

@@ -0,0 +1,9 @@
+RSpec::Matchers.define :be_a_flow_control do |condition_type|
+  match do |tree|
+     tree.should be_a_statement
+     if_element =  tree.elements.first.get_element(0, child: 0)
+     if_element.should be_a condition_type
+     if_element.elements.first.should be_a Expression
+     if_element.elements[1].should be_a Block
+  end
+end

data/spec/helpers/functions_helper.rb

@@ -0,0 +1,9 @@
+RSpec::Matchers.define :be_a_function_call do |identifier|
+  match do |tree|
+    tree.should be_a_statement
+    tree.get_element(1).should be_a Expression
+    tree.get_element(2).should be_a FunctionCall
+    tree.get_element(2, child: 0).should be_a Identifier
+    tree.get_element(2, child: 0).text_value.should eq(identifier)
+  end
+end

data/spec/helpers/statement_helper.rb

@@ -0,0 +1,6 @@
+RSpec::Matchers.define :be_a_statement do
+  match do |tree|
+    tree.should be_a Block
+    tree.get_element(0).should be_a Statement
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'ap'
+required_files = []
+required_files.concat Dir[File.join(File.dirname(__FILE__), 'helpers', '**', '*.rb')]
+required_files << File.join(File.dirname(__FILE__), '..', 'lib', 'myl_parser.rb')
+required_files.each do |file|
+  require File.expand_path file
+end
+
+include MylReferenceParser
+
+def parse(data)
+  if ENV['Myl'] == 'print'
+    begin
+      file = File.open(File.join(File.dirname(__FILE__), '..', 'code_example.md'), 'a')
+      file.write("\n```\n#{data}\n```\n")
+    rescue IOError => e
+      puts 'error while writing to file '
+    ensure
+      file.close unless file == nil
+    end
+  end
+  TreeParser.parse(data)
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: myl-parser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- facenord
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Parser for the myl language inspired by the koi language
+email:
+- facenord.sud@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- code_example.md
+- lib/myl_parser.rb
+- lib/parser/exceptions.rb
+- lib/parser/myl_parser.treetop
+- lib/parser/syntax_node_extensions.rb
+- lib/parser/syntax_nodes.rb
+- lib/parser/tree_parser.rb
+- run_gurad.rb
+- spec/assignement/assignement_spec.rb
+- spec/expressions/comparaison_expressions_spec.rb
+- spec/expressions/compund_expressions_spec.rb
+- spec/expressions/simple_expressions_spec.rb
+- spec/flow_control/if_unless_spec.rb
+- spec/functions/functions_call_spec.rb
+- spec/helpers/assignement_helper.rb
+- spec/helpers/expression_helper.rb
+- spec/helpers/flow_control_helper.rb
+- spec/helpers/functions_helper.rb
+- spec/helpers/statement_helper.rb
+- spec/spec_helper.rb
+homepage: https://github.com/facenord-sud/myl
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: The first for implementing the myl language. The parser which is returning
+  an AST. Using Treetop, based on the PEG
+test_files:
+- spec/assignement/assignement_spec.rb
+- spec/expressions/comparaison_expressions_spec.rb
+- spec/expressions/compund_expressions_spec.rb
+- spec/expressions/simple_expressions_spec.rb
+- spec/flow_control/if_unless_spec.rb
+- spec/functions/functions_call_spec.rb
+- spec/helpers/assignement_helper.rb
+- spec/helpers/expression_helper.rb
+- spec/helpers/flow_control_helper.rb
+- spec/helpers/functions_helper.rb
+- spec/helpers/statement_helper.rb
+- spec/spec_helper.rb
+has_rdoc: