rip-parser 0.1.0

data/source/rip/parser/rules/import.rb

@@ -0,0 +1,23 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './keyword'
+require_relative './string'
+
+module Rip::Parser::Rules
+  module Import
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::Keyword
+    include Rip::Parser::Rules::String
+
+    rule(:import) { keyword(:import) >> (import_bare | import_parens) }
+
+    rule(:import_bare) { spaces >> module_name }
+
+    rule(:import_parens) { parenthesis_open >> module_name >> spaces? >> parenthesis_close }
+
+    rule(:module_name) { spaces? >> (string_symbol | string_double).as(:module_name) }
+  end
+end

data/source/rip/parser/rules/invocation.rb

@@ -0,0 +1,15 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './list'
+
+module Rip::Parser::Rules
+  module Invocation
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::List
+
+    rule(:invocation) { parenthesis_open.as(:location) >> csv(expression).as(:arguments) >> parenthesis_close }
+  end
+end

data/source/rip/parser/rules/invocation_index.rb

@@ -0,0 +1,15 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './list'
+
+module Rip::Parser::Rules
+  module InvocationIndex
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::List
+
+    rule(:invocation_index) { bracket_open.as(:location) >> csv(expression).as(:index_arguments) >> bracket_close }
+  end
+end

data/source/rip/parser/rules/keyword.rb

@@ -0,0 +1,12 @@
+require 'parslet'
+
+module Rip::Parser::Rules
+  module Keyword
+    include ::Parslet
+
+    def keyword(word)
+      keyword = Rip::Parser::Keyword[word]
+      str(keyword.source_text).as(keyword.name)
+    end
+  end
+end

data/source/rip/parser/rules/lambda.rb

@@ -0,0 +1,45 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './keyword'
+require_relative './list'
+require_relative './reference'
+
+module Rip::Parser::Rules
+  module Lambda
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::Keyword
+    include Rip::Parser::Rules::List
+    include Rip::Parser::Rules::Reference
+
+    rule(:lambda_block) do
+      keyword(:fat_rocket) >> whitespaces? >> brace_open >> whitespaces? >>
+        (whitespaces? >> overload_block >> whitespaces?).repeat(1).as(:overloads) >>
+        whitespaces? >> brace_close
+    end
+
+    rule(:overload_block) do
+      parameters.maybe >> whitespaces? >>
+        keyword(:dash_rocket) >> whitespaces? >> block_body
+    end
+
+    rule(:parameters) do
+      parenthesis_open >> whitespaces? >> parameters_list.as(:parameters) >> whitespaces? >> parenthesis_close
+    end
+
+    rule(:parameters_list) { csv(optional_parameter | required_parameter) }
+
+    rule(:required_parameter) { word.as(:parameter) >> parameter_type_argument.maybe }
+    rule(:optional_parameter) { required_parameter >> spaces >> equals >> whitespaces >> expression.as(:default) }
+
+    rule(:parameter_type_argument) { angled_open >> spaces? >> reference.as(:type_argument) >> spaces? >> angled_close }
+
+    def block_body(label = :body)
+      brace_open >> whitespaces? >>
+        nested_lines.as(label) >>
+        whitespaces? >> brace_close
+    end
+  end
+end

data/source/rip/parser/rules/list.rb

@@ -0,0 +1,18 @@
+require 'parslet'
+
+require_relative './common'
+
+module Rip::Parser::Rules
+  module List
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+
+    rule(:list) { bracket_open.as(:location) >> whitespaces? >> csv(expression).as(:list) >> whitespaces? >> bracket_close }
+
+    def csv(value)
+      _value = whitespaces? >> value >> whitespaces?
+      (_value >> (comma >> _value).repeat).repeat(0, 1)
+    end
+  end
+end

data/source/rip/parser/rules/map.rb

@@ -0,0 +1,15 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './list'
+
+module Rip::Parser::Rules
+  module Map
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::List
+
+    rule(:map) { brace_open.as(:location) >> whitespaces? >> csv(expression).as(:map) >> whitespaces? >> brace_close }
+  end
+end

data/source/rip/parser/rules/module.rb

@@ -0,0 +1,29 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './assignment'
+require_relative './expression'
+
+module Rip::Parser::Rules
+  module Module
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::Assignment
+    include Rip::Parser::Rules::Expression
+
+    rule(:module) { root_lines.as(:module) }
+
+    rule(:root_lines) do
+      whitespaces? >> (reference_assignment | expression) >> spaces? >> (
+        (semicolon | line_break) >> whitespaces? >> root_lines
+      ).repeat >> whitespaces?
+    end
+
+    rule(:nested_lines) do
+      whitespaces? >> (property_assignment | reference_assignment | expression) >> spaces? >> (
+        (semicolon | line_break) >> whitespaces? >> nested_lines
+      ).repeat >> whitespaces?
+    end
+  end
+end

data/source/rip/parser/rules/number.rb

@@ -0,0 +1,21 @@
+require 'parslet'
+
+require_relative './common'
+
+module Rip::Parser::Rules
+  module Number
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+
+    rule(:number) { sign.maybe >> (decimal | integer) }
+
+    rule(:sign) { match['+-'].as(:sign) }
+
+    rule(:decimal) { integer >> dot >> digits.as(:decimal) }
+    rule(:integer) { digits.as(:integer) }
+
+    rule(:digit) { match['0-9'] }
+    rule(:digits) { digit.repeat(1) >> (underscore.maybe >> digit.repeat(1)).repeat }
+  end
+end

data/source/rip/parser/rules/pair.rb

@@ -0,0 +1,13 @@
+require 'parslet'
+
+require_relative './common'
+
+module Rip::Parser::Rules
+  module Pair
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+
+    rule(:pair_value) { spaces? >> colon.as(:location) >> spaces? >> expression.as(:value) }
+  end
+end

data/source/rip/parser/rules/property.rb

@@ -0,0 +1,33 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './reference'
+
+module Rip::Parser::Rules
+  module Property
+    SPECIAL_NAMES = [
+      '/',
+      '/%',
+      '<',
+      '<<',
+      '<=',
+      '<=>',
+      '>',
+      '>>',
+      '>=',
+      '[]',
+      '|>'
+    ]
+
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::Reference
+
+    rule(:property) { whitespaces? >> dot.as(:location) >> whitespaces? >> property_name.as(:property_name) }
+
+    rule(:property_name) { property_name_special | word }
+
+    rule(:property_name_special) { SPECIAL_NAMES.map(&method(:str)).inject(&:|) }
+  end
+end

data/source/rip/parser/rules/range.rb

@@ -0,0 +1,15 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './character'
+
+module Rip::Parser::Rules
+  module Range
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::Reference
+
+    rule(:range_end) { spaces? >> (dot >> dot).as(:location) >> spaces? >> expression.as(:end) }
+  end
+end

data/source/rip/parser/rules/reference.rb

@@ -0,0 +1,16 @@
+require 'parslet'
+
+require_relative './number'
+
+module Rip::Parser::Rules
+  module Reference
+    include ::Parslet
+
+    include Rip::Parser::Rules::Number
+
+    rule(:reference) { word.as(:reference) }
+
+    rule(:word) { word_legal >> (word_legal | digit).repeat }
+    rule(:word_legal) { match['^\d\s\`\'",.:;#\/\\()<>\[\]{}'] }
+  end
+end

data/source/rip/parser/rules/string.rb

@@ -0,0 +1,41 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './character'
+
+module Rip::Parser::Rules
+  module String
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::Character
+
+    rule(:string) { string_symbol | string_double | heredoc }
+
+    rule(:string_symbol) { colon.as(:location) >> character_legal.as(:character).repeat(1).as(:string) }
+
+    rule(:string_double)      { string_parser(quote_double, escape_sequence, :string) }
+    rule(:regular_expression) { string_parser(slash_forward, escape_sequence, :regular_expression) }
+
+    rule(:quote_single) { str('\'') }
+    rule(:quote_double) { str('"') }
+
+    rule(:heredoc) { heredoc_start >> heredoc_content.as(:string) >> heredoc_end }
+
+    rule(:heredoc_start) { angled_open.repeat(2, 2).as(:location) >> match['A-Z_'].repeat(1).capture(:heredoc_label).as(:label) >> line_break }
+
+    rule(:heredoc_content) { (heredoc_end.absent? >> (interpolation | escape_sequence | any.as(:character))).repeat }
+
+    rule(:heredoc_end) do
+      dynamic do |source, context|
+        spaces? >> str(context.captures[:heredoc_label]) >> (line_break | eof)
+      end
+    end
+
+    rule(:interpolation) { (pound >> brace_open).as(:location) >> whitespaces? >> expression.as(:interpolation) >> whitespaces? >> brace_close }
+
+    def string_parser(delimiter, inner_special, label)
+      delimiter.as(:location) >> (delimiter.absent? >> (interpolation | inner_special | any.as(:character))).repeat.as(label) >> delimiter
+    end
+  end
+end

data/source/rip/parser/rules/unit.rb

@@ -0,0 +1,17 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './number'
+require_relative './reference'
+
+module Rip::Parser::Rules
+  module Unit
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::Number
+    include Rip::Parser::Rules::Reference
+
+    rule(:unit) { number.as(:magnitude) >> word.as(:label) }
+  end
+end

data/source/rip/parser/rules.rb

@@ -0,0 +1,7 @@
+module Rip::Parser
+  module Rules
+  end
+end
+
+pattern = Pathname.new(__dir__).join('rules/*.rb')
+Pathname.glob(pattern).each(&method(:require))