rip-parser 0.1.0

data/rip-parser.gemspec

@@ -0,0 +1,20 @@
+require_relative './source/rip/parser/about'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rip-parser'
+  spec.version       = Rip::Parser::About.version
+  spec.author        = 'Thomas Ingram'
+  spec.license       = 'MIT'
+  spec.summary       = 'Composable parser for Rip'
+  spec.homepage      = 'http://www.rip-lang.org/'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.require_paths = [ 'source' ]
+
+  spec.add_runtime_dependency 'parslet', '~> 1.7.0'
+
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-doc'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/source/rip/parser/about.rb

@@ -0,0 +1,9 @@
+module Rip
+  module Parser
+    module About
+      def self.version
+        '0.1.0'
+      end
+    end
+  end
+end

data/source/rip/parser/error.rb

@@ -0,0 +1,36 @@
+module Rip::Parser
+  class Error < StandardError
+    attr_reader :code
+
+    def initialize(message)
+      super
+      @code = 10
+    end
+  end
+
+  class SyntaxError < Error
+    attr_reader :location
+    attr_reader :cause
+
+    def initialize(message, location, cause)
+      super(message)
+
+      @location = location
+      @cause = cause
+      @code = 11
+    end
+  end
+
+  class NormalizeError < Error
+    attr_reader :origin
+    attr_reader :tree
+
+    def initialize(message, origin, tree = nil)
+      super(message)
+
+      @origin = origin
+      @tree = tree
+      @code = 12
+    end
+  end
+end

data/source/rip/parser/grammar.rb

@@ -0,0 +1,23 @@
+require 'parslet'
+
+require_relative './rules'
+
+module Rip::Parser
+  class Grammar
+    include Rip::Parser::Rules::Module
+
+    def self.parse(origin, source_code)
+      begin
+        raw_tree = new.module.parse(source_code)
+        Rip::Parser::Utilities::Normalizer.apply(origin, raw_tree)
+      rescue Parslet::ParseFailed => e
+        match = /\A.+ at line (\d+) char (\d+)\.\z/.match(e.message)
+        line, column = match ? match.values_at(1, 2).map(&:to_i) : [ 0, 0 ]
+        location = Rip::Parser::Location.new(origin, e.cause.pos.charpos, line, column)
+        raise Rip::Parser::SyntaxError.new(e.message, location, e.cause)
+      end
+    end
+  end
+end
+
+require_relative './utilities/normalizer'

data/source/rip/parser/keywords.rb

@@ -0,0 +1,84 @@
+module Rip::Parser
+  class Keyword
+    attr_reader :name
+    attr_reader :source_text
+
+    def initialize(name, source_text = name)
+      @name = name.to_sym
+      @source_text = source_text.to_s
+    end
+
+    def ==(other)
+      name == other.name
+    end
+
+    def to_debug
+      name
+    end
+
+    def self.[](name)
+      Keywords.all.detect do |keyword|
+        keyword.name == name
+      end.tap do |keyword|
+        raise "Unknown keyword: `#{name}`" if keyword.nil?
+      end
+    end
+  end
+
+  module Keywords
+    def self.all
+      [
+        conditional,
+        dependency,
+        exceptional,
+        object,
+        pseudo,
+        query,
+        transfer
+      ].inject(&:+)
+    end
+
+    def self.conditional
+      make_keywords(:if, :switch, :case, :else)
+    end
+
+    def self.dependency
+      make_keywords(:import)
+    end
+
+    def self.exceptional
+      make_keywords(:try, :catch, :finally)
+    end
+
+    def self.object
+      [
+        *make_keywords(:class, :enum, :interface),
+        Keyword.new(:swerve_rocket, '~>'),
+        Keyword.new(:dash_rocket, '->'),
+        Keyword.new(:fat_rocket, '=>')
+      ]
+    end
+
+    def self.pseudo
+      [
+        Keyword.new(:class_self, 'self'),
+        Keyword.new(:class_prototype, '@'),
+        Keyword.new(:lambda_receiver, '@')
+      ]
+    end
+
+    def self.query
+      make_keywords(:from, :as, :join, :union, :on, :where, :order, :select, :limit, :take)
+    end
+
+    def self.transfer
+      make_keywords(:exit, :return, :throw)
+    end
+
+    protected
+
+    def self.make_keywords(*names)
+      names.map { |name| Keyword.new(name) }
+    end
+  end
+end

data/source/rip/parser/location.rb

@@ -0,0 +1,47 @@
+module Rip::Parser
+  class Location
+    attr_reader :origin  # label where source code is coming from
+    attr_reader :offset  # zero-based offset from begining of file
+    attr_reader :line    # one-based line number
+    attr_reader :column  # one-based character on line
+    attr_reader :length  # how many characters are covered
+
+    def initialize(origin, offset, line, column, length = 0)
+      @origin = origin
+      @offset = offset
+      @line = line
+      @column = column
+      @length = length
+    end
+
+    def ==(other)
+      (origin == other.origin) &&
+        (offset == other.offset)
+    end
+
+    def add_character(count = 1)
+      self.class.new(origin, offset + count, line, column + count, length)
+    end
+
+    def add_line(count = 1)
+      self.class.new(origin, offset + count, line + count, 1, length)
+    end
+
+    def inspect
+      "#<#{self.class.name} #{self}>"
+    end
+
+    def to_s
+      "#{origin}:#{to_debug}"
+    end
+
+    def to_debug
+      offset_length = length.zero? ? offset : (offset..(offset + length - 1))
+      "#{line}:#{column}(#{offset_length})"
+    end
+
+    def self.from_slice(origin, slice, length = slice.length)
+      new(origin, slice.offset, *slice.line_and_column, length)
+    end
+  end
+end

data/source/rip/parser/node.rb

@@ -0,0 +1,115 @@
+module Rip::Parser
+  class Node
+    include Enumerable
+
+    attr_reader :location
+    attr_reader :type
+    attr_reader :extra
+
+    def initialize(location:, type:, **extra)
+      @location = location
+      @type = type
+      @extra = extra.inject({}) do |memo, (key, value)|
+        memo.merge(key => self.class.try_convert(value))
+      end
+    end
+
+    def ==(other)
+      to_h == other.to_h
+    end
+
+    def [](key)
+      case key.to_sym
+        when :location then location
+        when :type     then type
+        else                extra[key.to_sym]
+      end
+    end
+
+    def each(&block)
+      to_h.each(&block)
+    end
+
+    def key?(key)
+      extra.key?(key.to_sym)
+    end
+
+    def keys
+      extra.keys
+    end
+
+    def length
+      location.length
+    end
+
+    def merge(other)
+      self.class.new(extra.merge(other.to_h).merge(location: location, type: other[:type] || type))
+    end
+
+    def s_expression
+      _extra = extra.map do |key, value|
+        [ key, self.class.try_convert_s_expression(value) ]
+      end.to_h
+
+      { type: type }.merge(_extra)
+    end
+
+    def to_h
+      _extra = extra.map do |key, value|
+        [ key, self.class.try_convert_to_h(value) ]
+      end.to_h
+
+      { location: location, type: type }.merge(_extra)
+    end
+
+    private
+
+    def method_missing(missing_method, *args, &block)
+      case
+      when key?(missing_method)
+        extra[missing_method]
+      when missing_method.to_s.end_with?('?')
+        missing_method.to_s.sub(/\?\z/, '').to_sym == type
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_all)
+      key?(name) || name.to_s.end_with?('?')
+    end
+
+    def self.try_convert(value)
+      case value
+      when Array
+        value.map(&method(:try_convert))
+      when Hash
+        new(value)
+      else
+        value
+      end
+    end
+
+    def self.try_convert_to_h(value)
+      case value
+      when Array
+        value.map(&method(:try_convert_to_h))
+      when self
+        value.to_h
+      else
+        value
+      end
+    end
+
+    def self.try_convert_s_expression(value)
+      case value
+      when Array
+        value.map(&method(:try_convert_s_expression))
+      when self
+        value.s_expression
+      else
+        value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './expression'
+require_relative './property'
+require_relative './reference'
+
+module Rip::Parser::Rules
+  module Assignment
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::Expression
+    include Rip::Parser::Rules::Property
+    include Rip::Parser::Rules::Reference
+
+    rule(:reference_assignment) { reference.as(:lhs) >> assignment_rhs }
+
+    rule(:property_assignment) { (reference.as(:object) >> property).as(:lhs) >> assignment_rhs }
+
+    rule(:assignment_rhs) { spaces >> equals.as(:location) >> whitespaces >> expression.as(:rhs) }
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './lambda'
+require_relative './keyword'
+
+module Rip::Parser::Rules
+  module BinaryCondition
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::Lambda
+    include Rip::Parser::Rules::Keyword
+
+    rule(:binary_condition) do
+      keyword(:if) >> whitespaces? >>
+        parenthesis_open >> whitespaces? >>
+        expression.as(:condition) >>
+        parenthesis_close >> whitespaces? >>
+        block_body(:consequence) >> whitespaces? >>
+        keyword(:else) >> whitespaces? >> block_body(:alternative)
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './number'
+require_relative './reference'
+
+module Rip::Parser::Rules
+  module Character
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::Number
+    include Rip::Parser::Rules::Reference
+
+    SPECIAL_ESCAPES = {
+      quote_single:    "'",
+      quote_double:    '"',
+      backslash:       '\\',
+      bell:            'a',
+      backspace:       'b',
+      form_feed:       'f',
+      new_line:        'n',
+      carriage_return: 'r',
+      tab_horizontal:  't',
+      tab_vertical:    'v'
+    }
+
+    rule(:character) { backtick.as(:location) >> (escape_sequence | character_legal.as(:character)) }
+
+    rule(:character_legal) { digit | word_legal }
+
+    rule(:backtick) { str('`') }
+
+    rule(:escape_sequence) { slash_back.as(:escape_location) >> (escape_sequence_unicode | escape_sequence_special | escape_sequence_any) }
+
+    rule(:escape_sequence_unicode) { str('u') >> match['0-9a-f'].repeat(4, 4).as(:escape_unicode) }
+    rule(:escape_sequence_special) { SPECIAL_ESCAPES.values.map(&method(:str)).inject(&:|).as(:escape_special) }
+    rule(:escape_sequence_any)     { match['\S'].as(:escape_any) }
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './keyword'
+require_relative './lambda'
+require_relative './property'
+require_relative './reference'
+
+module Rip::Parser::Rules
+  module Class
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::Keyword
+    include Rip::Parser::Rules::Lambda
+    include Rip::Parser::Rules::Property
+    include Rip::Parser::Rules::Reference
+
+    rule(:class_block) do
+      keyword(:class) >> spaces? >> class_ancestors.maybe >> whitespaces? >> brace_open >>
+        class_body.maybe.as(:body) >>
+        whitespaces? >> brace_close
+    end
+
+    rule(:class_ancestors) do
+      parenthesis_open >> whitespaces? >>
+        csv(reference).as(:ancestors) >>
+        whitespaces? >> parenthesis_close
+    end
+
+    rule(:class_body) do
+      whitespaces? >> class_property_assignment >> spaces? >> (
+        (semicolon | line_break) >> whitespaces? >> class_body
+      ).repeat(0) >> whitespaces?
+    end
+
+    rule(:class_property_assignment) do
+      class_property.as(:property) >> spaces >>
+        equals.as(:location) >> whitespaces >>
+        property_value.as(:property_value)
+    end
+
+    rule(:class_property) do
+      keyword(:class_prototype) >> property |
+        keyword(:class_self) >> property |
+        word.as(:property_name)
+    end
+
+    rule(:property_value) do
+      import |
+        class_block |
+        lambda_block |
+        overload_block |
+        property_block |
+        expression
+    end
+
+    rule(:property_block) { keyword(:swerve_rocket) >> whitespaces? >> block_body }
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'parslet'
+
+module Rip::Parser::Rules
+  module Common
+    include ::Parslet
+
+    rule(:whitespace) { space | line_break | comment }
+    rule(:whitespaces) { whitespace.repeat(1) }
+    rule(:whitespaces?) { whitespaces.maybe }
+
+    rule(:space) { str(' ') | str("\t") }
+    rule(:spaces) { space.repeat(1) }
+    rule(:spaces?) { spaces.maybe }
+
+    rule(:line_break) { str("\r\n") | str("\n") | str("\r") }
+    rule(:line_breaks) { line_break.repeat(1) }
+    rule(:line_breaks?) { line_breaks.maybe }
+
+    rule(:comment) { pound >> (line_break.absent? >> any).repeat >> (line_break | eof) }
+
+    rule(:eof) { any.absent? }
+
+    rule(:dot) { str('.') }
+    rule(:comma) { str(',') }
+    rule(:semicolon) { str(';') }
+    rule(:colon) { str(':') }
+    rule(:pound) { str('#') }
+    rule(:dash) { str('-') }
+    rule(:underscore) { str('_') }
+    rule(:equals) { str('=') }
+
+    rule(:slash_back) { str('\\') }
+    rule(:slash_forward) { str('/') }
+
+    rule(:angled_open) { str('<') }
+    rule(:angled_close) { str('>') }
+
+    rule(:brace_open) { str('{') }
+    rule(:brace_close) { str('}') }
+
+    rule(:bracket_open) { str('[') }
+    rule(:bracket_close) { str(']') }
+
+    rule(:parenthesis_open) { str('(') }
+    rule(:parenthesis_close) { str(')') }
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'parslet'
+
+require_relative './common'
+require_relative './number'
+
+module Rip::Parser::Rules
+  module DateTime
+    include ::Parslet
+
+    include Rip::Parser::Rules::Common
+    include Rip::Parser::Rules::Number
+
+    rule(:date_time) { date.as(:date) >> str('T') >> time.as(:time) }
+
+    rule(:date) do
+      digit.repeat(4, 4).as(:year) >> dash >>
+        digit.repeat(2, 2).as(:month) >> dash >>
+        digit.repeat(2, 2).as(:day)
+    end
+
+    rule(:time) do
+      digit.repeat(2, 2).as(:hour) >> colon >>
+        digit.repeat(2, 2).as(:minute) >> colon >>
+        digit.repeat(2, 2).as(:second) >>
+        (dot >> digits.as(:sub_second)).maybe >>
+        (
+          sign >> digit.repeat(2, 2).as(:hour) >> digit.repeat(2, 2).as(:minute)
+        ).as(:offset).maybe
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+require 'parslet'
+
+require_relative './binary_condition'
+require_relative './class'
+require_relative './character'
+require_relative './common'
+require_relative './date_time'
+require_relative './import'
+require_relative './invocation'
+require_relative './invocation_index'
+require_relative './keyword'
+require_relative './lambda'
+require_relative './list'
+require_relative './map'
+require_relative './number'
+require_relative './pair'
+require_relative './property'
+require_relative './range'
+require_relative './reference'
+require_relative './string'
+require_relative './unit'
+
+module Rip::Parser::Rules
+  module Expression
+    include ::Parslet
+
+    include Rip::Parser::Rules::BinaryCondition
+
+    include Rip::Parser::Rules::Common
+
+    include Rip::Parser::Rules::Class
+
+    include Rip::Parser::Rules::DateTime
+
+    include Rip::Parser::Rules::Number
+
+    include Rip::Parser::Rules::Character
+    include Rip::Parser::Rules::String
+
+    include Rip::Parser::Rules::Lambda
+
+    include Rip::Parser::Rules::List
+
+    include Rip::Parser::Rules::Keyword
+
+    include Rip::Parser::Rules::Import
+
+    include Rip::Parser::Rules::Invocation
+    include Rip::Parser::Rules::InvocationIndex
+
+    include Rip::Parser::Rules::Map
+
+    include Rip::Parser::Rules::Pair
+
+    include Rip::Parser::Rules::Property
+
+    include Rip::Parser::Rules::Range
+
+    include Rip::Parser::Rules::Reference
+
+    include Rip::Parser::Rules::Unit
+
+    rule(:expression) { expression_chain }
+
+    rule(:expression_chain) do
+      (
+        (
+          expression_base |
+            (parenthesis_open >> whitespaces? >> expression_chain >> whitespaces? >> parenthesis_close)
+        ) >> expression_link.repeat
+      ).as(:expression_chain)
+    end
+
+    rule(:expression_base) do
+      import |
+
+        class_block |
+
+        lambda_block |
+        overload_block |
+
+        # enum_block |
+
+        binary_condition |
+
+        # switch_block |
+
+        # exception_block_sequence |
+
+        date_time |
+        date |
+        time |
+
+        unit |
+
+        # version | # maybe
+
+        number |
+
+        character |
+
+        string |
+        regular_expression |
+
+        # markup_fragment |
+
+        list |
+
+        map |
+
+        reference
+    end
+
+    rule(:expression_link) do
+      property |
+        pair_value |
+        range_end |
+        invocation |
+        invocation_index
+    end
+  end
+end